# leptos-rs/leptos

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/leptos-rs-leptos).**

20,142 stars · 841 forks · Rust · mit

## Links

- GitHub: https://github.com/leptos-rs/leptos
- Homepage: https://leptos.dev
- awesome-repositories: https://awesome-repositories.com/repository/leptos-rs-leptos.md

## Topics

`dom` `fine-grained` `isomorphic` `reactive` `rust` `ssr` `web` `webassembly`

## Description

Leptos is a full-stack Rust web framework designed for building reactive applications that share logic and types between the server and the browser. It provides a comprehensive toolkit for developing web interfaces where specific DOM nodes update automatically in response to changes in underlying reactive signals, rather than re-rendering entire component trees.

The framework distinguishes itself through a fine-grained reactivity model that tracks dependencies at the individual data point level. It utilizes compile-time template transformation to convert declarative HTML-like syntax into optimized imperative instructions, and supports isomorphic server-side rendering with streaming HTML delivery. By employing component-based hydration islands, it minimizes the amount of JavaScript sent to the client, attaching interactivity only where necessary.

Beyond its core rendering model, the project covers a broad surface of full-stack capabilities, including type-safe remote procedure calls that allow client-side code to invoke server-side functions directly. It integrates asynchronous data management, nested routing, and state synchronization between the server and client, while providing tools for managing component lifecycles and memory through a reactive ownership tree.

The framework includes a CLI for bootstrapping projects, orchestrating full-stack builds, and automating development cycles with live recompilation. It is documented to support various deployment strategies, including static hosting, containerized server-side applications, and serverless environments.

## Tags

### Web Development

- [Full-Stack Web Frameworks](https://awesome-repositories.com/f/web-development/full-stack-web-frameworks.md) — Functions as a full-stack Rust web framework for building reactive applications. ([source](https://book.leptos.dev/))
- [Full-Stack Web Development](https://awesome-repositories.com/f/web-development/backend-development/web-frameworks/full-stack-frameworks/full-stack-web-development.md) — Provides a full-stack environment for sharing logic, types, and state between server and browser.
- [Reactive State Management](https://awesome-repositories.com/f/web-development/reactive-state-management.md) — Provides a reactive framework for building interactive web interfaces with fine-grained state updates. ([source](https://book.leptos.dev/view/index.html))
- [Server-Side Rendering](https://awesome-repositories.com/f/web-development/rendering-templating/server-side-rendering.md) — Generates dynamic HTML content on the server to improve initial load times and search engine visibility. ([source](https://book.leptos.dev/01_introduction.html))
- [Server Functions](https://awesome-repositories.com/f/web-development/web-infrastructure-deployment/web-infrastructure-servers/server-functions.md) — Invokes server-side functions from the browser as local asynchronous calls with automatic serialization. ([source](https://book.leptos.dev/server/25_server_functions.html))
- [Web Development](https://awesome-repositories.com/f/web-development.md) — Offers a comprehensive toolkit for compiling high-performance web applications in Rust.
- [Path-Based Routers](https://awesome-repositories.com/f/web-development/route-path-aliasing/path-based-routers.md) — Maps URL paths to specific view components with support for dynamic parameters and wildcard matching. ([source](https://book.leptos.dev/print.html))
- [Server-Side Rendering Frameworks](https://awesome-repositories.com/f/web-development/server-side-rendering-frameworks.md) — Acts as a server-side rendering framework that hydrates interactive components in the browser.
- [Web Application Routers](https://awesome-repositories.com/f/web-development/web-application-routers.md) — Match the current browser path and query parameters to specific application components to determine what content renders on the page. ([source](https://book.leptos.dev/router/index.html))
- [Client-Side Routers](https://awesome-repositories.com/f/web-development/client-side-routers.md) — Intercepts link clicks to render new pages in the browser using compiled code for seamless navigation. ([source](https://book.leptos.dev/ssr/22_life_cycle.html))
- [Keyed List Reconciliation](https://awesome-repositories.com/f/web-development/dom-patching/list-patching/keyed-list-reconciliation.md) — Renders keyed lists that efficiently reconcile DOM updates based on stable unique identifiers. ([source](https://book.leptos.dev/print.html))
- [HTML Streaming](https://awesome-repositories.com/f/web-development/html-streaming.md) — Delivers HTML fragments to the client as they become available to improve perceived performance. ([source](https://book.leptos.dev/ssr/23_ssr_modes.html))
- [Nested Routing](https://awesome-repositories.com/f/web-development/nested-routing.md) — Supports hierarchical navigation by nesting route definitions to display child views within parent layouts. ([source](https://book.leptos.dev/router/17_nested_routing.html))
- [Reactive Stores](https://awesome-repositories.com/f/web-development/reactive-stores.md) — Manages fine-grained reactive state using primitives like signals and stores. ([source](https://book.leptos.dev/view/04b_iteration.html))
- [Remote Procedure Calls](https://awesome-repositories.com/f/web-development/remote-procedure-calls.md) — Exposes server-side functions to the client as type-safe asynchronous calls with automatic serialization.
- [Island Architecture Frameworks](https://awesome-repositories.com/f/web-development/rendering-templating/rendering-patterns/island-architecture-frameworks.md) — Isolates interactive UI components within static pages to minimize client-side JavaScript execution.
- [Client-Side State Synchronizers](https://awesome-repositories.com/f/web-development/server-side-frameworks/reactive-frameworks/client-side-state-synchronizers.md) — Coordinates state between browser and server to enable seamless full-stack data flow. ([source](https://book.leptos.dev/01_introduction.html))
- [URL Construction](https://awesome-repositories.com/f/web-development/url-construction.md) — Extracts URL parameters and query strings as reactive signals that trigger updates when navigation changes. ([source](https://book.leptos.dev/router/18_params_and_queries.html))
- [Request Data Accessors](https://awesome-repositories.com/f/web-development/backend-development/request-response-handling/http-request-handling/request-data-accessors.md) — Retrieves request data like headers, cookies, and parameters within server-side functions. ([source](https://book.leptos.dev/server/26_extractors.html))
- [Derived State](https://awesome-repositories.com/f/web-development/derived-state.md) — Calculates reactive values that update automatically based on source state changes to ensure data consistency. ([source](https://book.leptos.dev/reactivity/working_with_signals.html))
- [Form Action Handlers](https://awesome-repositories.com/f/web-development/form-handling/form-action-handlers.md) — Binds HTML form submissions to asynchronous functions for reactive updates and progressive enhancement. ([source](https://book.leptos.dev/progressive_enhancement/action_form.html))
- [Programmatic Navigation](https://awesome-repositories.com/f/web-development/programmatic-navigation.md) — Enables programmatic page transitions with support for history stack management and state preservation. ([source](https://book.leptos.dev/router/19_a.html))
- [Rendering Mode Configurators](https://awesome-repositories.com/f/web-development/rendering-mode-configurators.md) — Supports selection between synchronous, asynchronous, and streaming rendering strategies for optimized performance. ([source](https://book.leptos.dev/progressive_enhancement/index.html))
- [Named Router Outlets](https://awesome-repositories.com/f/web-development/routing-systems/routing/named-router-outlets.md) — Provides designated injection points within parent components for rendering nested route views. ([source](https://book.leptos.dev/router/17_nested_routing.html))
- [Server-Side Rendering](https://awesome-repositories.com/f/web-development/server-side-rendering.md) — Ensures pages remain functional and accessible by generating initial HTML on the server. ([source](https://book.leptos.dev/progressive_enhancement/index.html))
- [Single-Page Applications](https://awesome-repositories.com/f/web-development/single-page-applications.md) — Compiles code to run as a single-page application in the browser for fast iteration. ([source](https://book.leptos.dev/getting_started/index.html))
- [HTTP Header Manipulators](https://awesome-repositories.com/f/web-development/backend-development/request-response-handling/http-utilities/http-header-manipulators.md) — Modifies HTTP response headers and status codes during server-side rendering or function execution. ([source](https://book.leptos.dev/server/27_response.html))
- [Children Management](https://awesome-repositories.com/f/web-development/children-management.md) — Supports passing nested content and functional templates into components for flexible, reusable structures. ([source](https://book.leptos.dev/view/09_component_children.html))
- [Component Composition](https://awesome-repositories.com/f/web-development/component-composition.md) — Enables nesting and wrapping components to allow flexible content injection within complex interfaces. ([source](https://book.leptos.dev/interlude_projecting_children.html))
- [Error Handling](https://awesome-repositories.com/f/web-development/error-handling.md) — Wraps components to catch rendering errors and display fallback interfaces instead of crashing. ([source](https://book.leptos.dev/print.html))
- [HTTP Redirects](https://awesome-repositories.com/f/web-development/http-redirects.md) — Instructs the browser to navigate to different URLs via server-side HTTP redirect responses. ([source](https://book.leptos.dev/server/27_response.html))
- [Lazy Loading](https://awesome-repositories.com/f/web-development/lazy-loading.md) — Fetches route-specific code and data concurrently during navigation to prevent loading waterfalls. ([source](https://book.leptos.dev/deployment/binary_size.html))
- [Async Loading State Handlers](https://awesome-repositories.com/f/web-development/performance-optimizations/lazy-loading-strategies/async-loading-state-handlers.md) — Integrates asynchronous data into the reactive system with automatic loading state management. ([source](https://book.leptos.dev/print.html))
- [Client-Side Navigation Components](https://awesome-repositories.com/f/web-development/routing-systems/routing/frontend-navigation-systems/client-side-navigation-components.md) — Intercepts form submissions to perform client-side navigation or data requests without full page reloads. ([source](https://book.leptos.dev/router/20_form.html))
- [Side Effect Synchronization](https://awesome-repositories.com/f/web-development/side-effect-synchronization.md) — Synchronizes reactive data changes with external browser APIs and custom logic automatically. ([source](https://book.leptos.dev/reactivity/14_create_effect.html))
- [URL State Management](https://awesome-repositories.com/f/web-development/url-state-management.md) — Stores application state in route parameters or query strings for persistent navigation and data updates. ([source](https://book.leptos.dev/progressive_enhancement/index.html))
- [Document Head Management](https://awesome-repositories.com/f/web-development/document-head-management.md) — Manages document head metadata dynamically from anywhere within the component tree. ([source](https://book.leptos.dev/metadata.html))
- [DOM Access References](https://awesome-repositories.com/f/web-development/dom-access-references.md) — Provides direct access to underlying DOM elements for manual manipulation or native API interaction. ([source](https://book.leptos.dev/web_sys.html))
- [Memory Lifecycle Managers](https://awesome-repositories.com/f/web-development/reactive-signals/memory-lifecycle-managers.md) — Uses reference counting to manage signal memory and disposal, preventing leaks when signals are shared. ([source](https://book.leptos.dev/appendix_life_cycle.html))
- [Streaming Server-Side Rendering](https://awesome-repositories.com/f/web-development/streaming-server-side-rendering.md) — Supports streaming server-side rendering and deferred component loading for improved performance. ([source](https://book.leptos.dev/server/28_async_quick_reference.html))

### User Interface & Experience

- [Fine-Grained Reactivity](https://awesome-repositories.com/f/user-interface-experience/fine-grained-reactivity.md) — Implements fine-grained reactivity to automatically update specific DOM nodes when underlying data changes. ([source](https://book.leptos.dev/))
- [Reactive UI Libraries](https://awesome-repositories.com/f/user-interface-experience/reactive-ui-libraries.md) — Provides a reactive UI library for building interfaces that update automatically via signal-based dependency tracking.
- [Signal-Based Reactivity](https://awesome-repositories.com/f/user-interface-experience/signal-based-reactivity.md) — Tracks state dependencies at the individual data point level to trigger targeted DOM updates without full tree re-renders.
- [Dynamic List Rendering](https://awesome-repositories.com/f/user-interface-experience/dynamic-list-rendering.md) — Updates dynamic lists efficiently using unique keys to track and reconcile changes. ([source](https://book.leptos.dev/view/04_iteration.html))
- [Interactive UI Components](https://awesome-repositories.com/f/user-interface-experience/interactive-ui-components.md) — Embeds interactive UI elements within static server-rendered pages to minimize client-side JavaScript. ([source](https://book.leptos.dev/islands.html))
- [Automatic Dependency Tracking](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/reactivity-systems/automatic-dependency-tracking/automatic-dependency-tracking.md) — Tracks reactive values and their dependencies automatically to ensure consistent UI updates. ([source](https://book.leptos.dev/reactivity/working_with_signals.html))
- [Asynchronous Data Fetching](https://awesome-repositories.com/f/user-interface-experience/asynchronous-data-fetching.md) — Fetches and updates data reactively using asynchronous closures that synchronize state between server and client. ([source](https://book.leptos.dev/server/28_async_quick_reference.html))
- [Context Providers](https://awesome-repositories.com/f/user-interface-experience/component-architectures/component-communication-patterns/component-data-passing/context-providers.md) — Shares data across component trees using context to avoid manual property drilling. ([source](https://book.leptos.dev/15_global_state.html))
- [Component Communication](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-apis/communication-data-flow/component-communication.md) — Facilitates data exchange between components using properties and callbacks to coordinate state updates. ([source](https://book.leptos.dev/view/08_parent_child.html))
- [HTML Attribute Bindings](https://awesome-repositories.com/f/user-interface-experience/layout-utilities/presentation-engines/template-engines/data-binding-syntax/html-attribute-bindings.md) — Updates HTML attributes reactively by binding them to signals or functions. ([source](https://book.leptos.dev/view/02_dynamic_attributes.html))
- [Reactive State Systems](https://awesome-repositories.com/f/user-interface-experience/reactive-state-systems.md) — Initializes application state and event listeners once, delegating updates to granular functions that respond to state changes. ([source](https://book.leptos.dev/reactivity/interlude_functions.html))
- [Reusable UI Components](https://awesome-repositories.com/f/user-interface-experience/reusable-ui-components.md) — Encapsulates user interface logic into modular, reusable components to maintain consistent interfaces. ([source](https://book.leptos.dev/view/03_components.html))
- [Asynchronous Content Rendering](https://awesome-repositories.com/f/user-interface-experience/asynchronous-content-rendering.md) — Displays fallback interfaces while waiting for asynchronous resources to resolve. ([source](https://book.leptos.dev/async/11_suspense.html))
- [Dependency Resolvers](https://awesome-repositories.com/f/user-interface-experience/asynchronous-data-fetching/dependency-resolvers.md) — Wraps asynchronous operations in reactive containers that track dependencies and provide access to results. ([source](https://book.leptos.dev/async/10_resources.html))
- [Lifecycle Coordinators](https://awesome-repositories.com/f/user-interface-experience/asynchronous-data-fetching/lifecycle-coordinators.md) — Coordinates asynchronous operations and tracks their status to trigger reactive UI updates. ([source](https://book.leptos.dev/print.html))
- [Component Lifecycle Hooks](https://awesome-repositories.com/f/user-interface-experience/component-lifecycle-hooks.md) — Executes custom logic at specific stages of a component's lifecycle, such as mounting or unmounting. ([source](https://book.leptos.dev/appendix_life_cycle.html))
- [Conditional Rendering](https://awesome-repositories.com/f/user-interface-experience/conditional-rendering.md) — Renders conditional content based on programming expressions within the view layer. ([source](https://book.leptos.dev/view/06_control_flow.html))
- [Form Handling](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/form-handling.md) — Supports standard HTML form elements to ensure core interactions remain operational without client-side scripts. ([source](https://book.leptos.dev/progressive_enhancement/index.html))
- [Links](https://awesome-repositories.com/f/user-interface-experience/links.md) — Upgrades standard links to perform seamless client-side transitions while resolving relative paths. ([source](https://book.leptos.dev/router/19_a.html))
- [Slot Content Passing](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/composition-rendering-patterns/component-rendering-patterns/slot-content-passing.md) — Injects non-interactive server-rendered content into interactive components without requiring client-side hydration. ([source](https://book.leptos.dev/islands.html))
- [Form Input Handling](https://awesome-repositories.com/f/user-interface-experience/form-input-handling.md) — Synchronizes form input elements with reactive signals using controlled or uncontrolled patterns. ([source](https://book.leptos.dev/print.html))
- [Input States](https://awesome-repositories.com/f/user-interface-experience/input-states.md) — Manages the synchronization of input values with reactive state variables. ([source](https://book.leptos.dev/view/05_forms.html))
- [Transition State Suppressors](https://awesome-repositories.com/f/user-interface-experience/ui-components/feedback-overlay-components/loading-indicators/loading-placeholders/transition-state-suppressors.md) — Maintains existing content display during background data loads to prevent flickering during updates. ([source](https://book.leptos.dev/async/12_transition.html))

### Software Engineering & Architecture

- [Signals & Reactivity](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/signals-reactivity.md) — Uses HTML-like syntax to define reactive interfaces that update DOM nodes automatically. ([source](https://book.leptos.dev/print.html))
- [Server-Side Logic Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/server-side-logic-frameworks.md) — Executes custom backend logic directly on the server for database access and file operations. ([source](https://book.leptos.dev/server/25_server_functions.html))
- [Reactive Data Stores](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/reactive-data-stores.md) — Wraps complex data structures in reactive containers that allow granular updates to individual fields. ([source](https://book.leptos.dev/15_global_state.html))
- [Reactive Effects](https://awesome-repositories.com/f/software-engineering-architecture/reactive-effects.md) — Triggers side-effect functions automatically in response to reactive data changes to minimize unnecessary re-execution. ([source](https://book.leptos.dev/reactivity/index.html))
- [Asynchronous Execution](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/asynchronous-execution.md) — Enables triggering asynchronous functions from synchronous code with reactive state tracking. ([source](https://book.leptos.dev/async/13_actions.html))
- [Error Handling Patterns](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-patterns.md) — Maps server-side errors to domain-specific types for consistent network-level error handling. ([source](https://book.leptos.dev/server/25_server_functions.html))
- [Component Slots](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/layering-presentation/application-layer-architectures/ui-architectures-patterns/component-slots.md) — Allows defining named slots within components for flexible content injection and layout composition. ([source](https://book.leptos.dev/view/09_component_children.html))
- [Context State Propagators](https://awesome-repositories.com/f/software-engineering-architecture/state-synchronization-patterns/context-state-propagators.md) — Propagates data and signals across interactive components using context to coordinate behavior without full-page reloads. ([source](https://book.leptos.dev/islands.html))
- [Lifecycle Management](https://awesome-repositories.com/f/software-engineering-architecture/reactive-primitives/lifecycle-management.md) — Manages the lifecycle and memory of reactive primitives by automatically disposing of resources when their parent component is unmounted.

### Development Tools & Productivity

- [Template Compilation Tools](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/template-compilation-tools/template-compilation-tools.md) — Transforms declarative HTML-like syntax into optimized imperative render functions during the build process.
- [Bundle Size Optimization](https://awesome-repositories.com/f/development-tools-productivity/bundle-size-optimization.md) — Provides build-time optimization strategies to reduce the size of compiled binary assets. ([source](https://book.leptos.dev/deployment/index.html))

### Graphics & Multimedia

- [Client Side Rendering](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/dom-web-rendering-strategies/client-side-rendering.md) — Compiles code to run in the browser for building interactive interfaces that execute on the user device. ([source](https://book.leptos.dev/csr_wrapping_up.html))

### Data & Databases

- [Application State Management](https://awesome-repositories.com/f/data-databases/application-state-management.md) — Injects shared resources like database connection pools into server-side functions via application state. ([source](https://book.leptos.dev/server/26_extractors.html))

### Business & Productivity Software

- [Explicit Dependency Watchers](https://awesome-repositories.com/f/business-productivity-software/data-change-listeners/explicit-dependency-watchers.md) — Triggers callbacks based on explicit dependency tracking to separate monitored data from execution logic. ([source](https://book.leptos.dev/reactivity/14_create_effect.html))

### DevOps & Infrastructure

- [Production Build Modes](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/configuration-lifecycle-management/build-configuration/production-build-modes.md) — Enables production build modes that optimize runtime performance and reduce final binary size. ([source](https://book.leptos.dev/deployment/index.html))