leptos-rs/leptos

This system is the Leptos web framework, a Rust-based library for building reactive, fine-grained user interfaces that support both client-side and server-side rendering. It provides a comprehensive ecosystem including a router, server functions for backend communication, and integrations with web servers like Axum and Actix. The repository serves as a reference implementation hub, containing numerous examples that demonstrate patterns such as islands architecture, static site generation, and integration with external services like databases and authentication providers.

84 changes.

This period focused on establishing the Leptos framework's core infrastructure, including a new reactive ownership model, a comprehensive router, and dedicated server-side rendering (SSR) primitives. The team expanded the ecosystem by introducing first-party integrations for Actix and Axum, adding utility components for metadata and control flow, and implementing hot-reloading support. Extensive documentation, governance policies, and a wide array of example applications were added to demonstrate these new capabilities and guide contributors.

65 changes.

This period focused on establishing the core infrastructure for the new Tachys UI framework and the underlying reactive\_graph system, introducing fine-grained primitives like signals, effects, and memoization. It also expanded server-side capabilities with a unified middleware layer, extensible codec system, and dedicated support for Axum, Actix, and WASI platforms. The work was complemented by a significant increase in example projects demonstrating these new features, including islands architecture, authentication patterns, and integration with external services.

10 changes.

This period focused on expanding the project's example suite with demonstrations of hexagonal architecture, WebSocket communication, lazy routing, and hot-patching workflows. Significant effort was also directed toward building robust test coverage, including regression suites, compile-time macro validation, and end-to-end testing for various integration points.

This location introduces a new example project that integrates the Leptos UI framework with the Bevy 3D game engine. It provides a working demo where a Leptos-based interface controls a 3D scene rendered via Bevy, specifically allowing users to move a cube in the 3D view using UI buttons. The implementation includes the necessary Rust modules for event handling between the client and the Bevy engine, scene setup, and routing.

_projects/bevy3d\ui · high confidence

The \examples/counters\ directory has been added, providing a starter application that showcases the framework's reactive system. It demonstrates managing a large list of counters (up to 1,000) using \ArcRwSignal\ for shared state, rendering the list with the \\<For\>\ component, and handling user interactions like adding, clearing, and incrementing values. The example includes necessary build configuration via \cargo-make\ and Playwright test support.

examples/counters · high confidence

A new example located in examples/error\_boundary demonstrates how to use the Leptos ErrorBoundary component to catch and display errors reactively. The example provides a user interface where entering a non-integer value triggers an error boundary, rendering a fallback UI that lists the current errors, while valid integer inputs display the parsed value. The project includes configuration for running via Trunk and Playwright for integration testing.

_examples/error\boundary · high confidence

This change introduces a new Hacker News example application built with Axum, demonstrating Leptos' capability to create both client-side rendered and server-side rendered apps with hydration in a single repository. The example includes standard project scaffolding such as a Makefile for build tasks, a Rust toolchain configuration for WASM targets, styling, and documentation to help users run and understand the setup.

_examples/hackernews\axum · high confidence

Introduces a new Hacker News clone example that demonstrates Leptos' capability to create both client-side rendered and server-side rendered applications with hydration within a single repository. The addition includes the necessary source files, styling, and configuration (such as \rust-toolchain.toml\ for WASM support and \Makefile.toml\ for build tasks) to allow users to run the example via \trunk serve\ or \cargo leptos watch\.

examples/hackernews · high confidence

This change introduces a new Hacker News example located in examples/hackernews\_islands\_axum that demonstrates Leptos' islands architecture using the Axum server framework. The example showcases client-side rendering, server-side rendering with hydration, and dynamic HTML compression. It includes a Dockerfile for containerized deployment, a Makefile.toml for build automation, and specific Cargo configuration for WASM builds, providing a complete reference implementation for users looking to adopt this stack.

_examples/hackernews\_islands\axum · high confidence

This change introduces a new example demonstrating how to run a Leptos server-side rendered application using WebAssembly in a JavaScript environment via Deno. The example includes the necessary configuration files (deno.jsonc, Makefile.toml, rust-toolchain.toml) and source code (run.ts) to build the WASM components and serve them, providing a reference for users wanting to deploy Leptos apps on Deno.

_examples/hackernews\_js\fetch · high confidence

Introduces a new TodoMVC example built with Leptos, demonstrating component interaction and reactive state management. The example includes a Rust implementation using signals for state, persistence via localStorage, and routing for filter modes (All, Active, Completed). It also bundles standard TodoMVC CSS assets and provides build configuration via cargo-make and Trunk.

examples/todomvc · high confidence

Introduces a new Rust/Leptos example project demonstrating a hexagonal (ports and adapters) architecture. The project includes a configurable service graph that swaps external service implementations (such as different database or AI wrappers) via Cargo features, a custom Axum middleware layer for sub-domain validation, and comprehensive unit tests using mock objects to verify domain logic in isolation. It also provides end-to-end Playwright tests and standard project scaffolding (license, gitignore, configuration).

projects/hexagonal-architecture · high confidence

A new benchmark example for the Leptos framework has been added to the examples directory. It replicates the standard js-framework-benchmark workload, creating a large table with randomized entries to demonstrate the usage of the \template\ macro and the \For\ component. The example includes a Makefile for build tasks, a README with quick-start instructions, and the necessary HTML and Rust source files to run the benchmark via Trunk.

examples/js-framework-benchmark · high confidence

Introduces a new example project in \projects/ory-kratos\ that demonstrates integrating Ory Kratos with a Leptos and Axum server. The project includes server-side functions to manage login, registration, recovery, settings, and logout flows by acting as an intermediary between the client and the Ory Kratos API. It features dynamic UI rendering that parses Kratos' UI data structures to generate forms, custom Axum extractors for session validation, and a SQLite database for user storage. The example also provides configuration files (\.env\, \.gitignore\), a public domain license, and comprehensive documentation on running the stack with Docker Compose and running end-to-end tests.

projects/ory-kratos · high confidence

Added a new example project under \projects/nginx-mpmc\ that demonstrates how to run multiple Leptos SSR servers (App-1, App-2, and two shared servers) behind an Nginx reverse proxy on a single domain (localhost:80). The entry includes the Nginx configuration files (\nginx.conf\, \nginx\_linux.conf\), shell scripts to run and kill the services (\run.sh\, \run\_linux.sh\, \kill.sh\), and the source code for the individual server components (\app-1\, \app-2\, \shared-server-1\, \shared-server-2\), illustrating how clients can communicate with different servers via specific proxy paths.

(repo-wide) · high confidence

The examples/portal directory now includes a complete demo application showcasing the Leptos Portal component. This example illustrates how to render content (such as an overlay) into a specific DOM node (the root 'app' element) regardless of the component's position in the virtual DOM tree, using signals to control visibility and nested portal content.

examples/portal · high confidence

A new example application has been added to demonstrate four distinct server-side rendering modes: Synchronous, Out-of-order streaming, In-order streaming, and Async. The example uses the \SsrMode\ configuration on routes to show how \Suspense\ boundaries and resource loading affect Time To First Byte (TTFB) and hydration, specifically illustrating how Async mode allows metadata to be set after data loads.

_examples/ssr\modes · high confidence

The benchmarks directory now includes new Rust source files (\lib.rs\, \reactive.rs\, \ssr.rs\) that provide performance comparisons for server-side rendering and reactive state management. The SSR benchmarks specifically measure rendering performance for Leptos, Tachys, Yew, Sycamore, and the Tera templating engine, while the reactive benchmarks compare Leptos and the legacy l0410 reactive system under deep creation, update, and signal propagation scenarios.

benchmarks/src, benchmarks/src/todomvc · high confidence

The \examples/tailwind\_csr\ directory has been added as a new starter template demonstrating how to integrate Tailwind CSS with the Leptos web framework using the Trunk build tool. This example configures Trunk to automatically build CSS via \Trunk.toml\ (specifying Tailwind version 4.1.13) and includes a client-side rendered (CSR) counter application. It also provides necessary configuration files such as \rust-toolchain.toml\ for the WASM target, a \Makefile.toml\ for cargo-make tasks, and a \README.md\ with setup instructions for VS Code and Tailwind CSS IntelliSense.

_examples/tailwind\csr · high confidence

A new example application demonstrates how to persist and synchronize state with URL query parameters using the \query\_signal\ hook from \leptos\_router\. The \SimpleQueryCounter\ component maintains a numeric counter and a text message, updating the browser's URL query string on changes and restoring state from the URL on load, providing a concrete pattern for URL-driven state management.

_examples/counter\_url\query · high confidence

This change introduces a new WebSocket example in the \examples/websocket\ directory, demonstrating a basic echo application built with Leptos and Axum. The example includes server-side logic using \server\_fn\ with WebSocket protocol support and client-side hydration. It also provides a comprehensive end-to-end testing suite using Cucumber and Fantoccini, featuring Gherkin scenarios that verify text echoing, page titles, and specific client/server error handling behaviors.

examples/websocket · high confidence

The \oco\ crate introduces the \Oco\ (Owned Clones Once) smart pointer, providing an alternative to \Cow\ with an additional reference-counted branch. This allows storing immutable values (such as strings) in a way that supports cheap cloning: \Borrowed\ and \Counted\ variants clone in O(1), while \Owned\ clones in O(n) but can be converted to \Counted\ via \clone\_inplace()\ for subsequent O(1) clones. The crate is published as \oco\_ref\ for external use.

oco · high confidence

A new fetch example demonstrates how to retrieve data from a remote API (theCatApi) in a WebAssembly environment. It showcases the use of LocalResource for data fetching, along with Suspense, Transition, and ErrorBoundary components to handle loading states and errors gracefully. The example also includes proper error handling and displays fetched cat images.

examples/fetch · high confidence

The const\_str\_slice\_concat crate now provides a new set of compile-time string manipulation utilities, including functions to concatenate static strings, concatenate with a prefix and suffix, and concatenate with a separator. These functions operate at compile time and are designed to work in no\_std environments, allowing developers to build string templates and formatted outputs without runtime overhead or standard library dependencies.

_const\_str\_slice\concat · high confidence

The counter\_isomorphic example has been added to demonstrate isomorphic server functions and real-time updates via Server-Sent Events (SSE). It includes a simple counter, a form-based counter, and a multi-user counter that shares state across browser tabs using a broadcast channel. The example is configured to run with cargo-leptos and uses Actix-web for the server implementation.

_examples/counter\isomorphic · high confidence

A new example application has been added to demonstrate the \use:\ directive syntax in Leptos. It includes three directive implementations—\highlight\ for toggling element styling, \copy\_to\_clipboard\ for copying text to the system clipboard, and \add\_dot\ for appending characters to element text—showing how to handle directives with no parameters, string parameters, and custom typed parameters.

examples/directives · high confidence

A new example has been added to illustrate four distinct methods for child components to communicate with their parent: passing a WriteSignal as a prop, passing a closure, attaching an event listener directly to a child component, and using context to share state. This provides users with concrete reference implementations for common parent-child interaction patterns in Leptos.

_examples/parent\child · high confidence

Introduces a new Axum-based demo project that serves dynamic sitemaps generated from a Postgres database of blog posts. The project includes a Dockerized database setup, a schema for blog posts, and an Axum route that queries the database to generate a sitemap-index.xml file on first request, which is then served with caching headers. It also serves a static sitemap file for comparison.

_projects/sitemap\axum · high confidence

The examples/slots directory now includes a complete example application that demonstrates how to define and use slots in Leptos. The example defines a \SlotIf\ component that accepts named slots (\Then\, \ElseIf\, \Fallback\) and renders the appropriate slot content based on signal conditions, showing users how to implement conditional slot logic similar to if/else statements.

examples/slots · high confidence

A new, stable example application is introduced that demonstrates a full-stack Leptos app using the Axum web framework and SQLite. It includes a complete project structure with a Rust backend (\main.rs\, \lib.rs\) that sets up an Axum router, manages database connections via \sqlx\, and exposes server functions for CRUD operations on todos. The frontend (\todo.rs\) utilizes Leptos components like \ErrorBoundary\, \Suspense\, and \ActionForm\ to provide a reactive UI, while supporting both server-side rendering and client-side hydration. The example also provides necessary configuration files (\rust-toolchain.toml\, \Makefile.toml\) and documentation to guide users on setup and running the application.

_examples/todo\_app\_sqlite\axum · high confidence

A new example application has been added to the \examples/stores\ directory that demonstrates how to use reactive stores in a client-side rendered TODO application. The example showcases key store capabilities including keyed fields for efficient iteration, type-erased store fields, support for simple enums (such as \Status\), and the ability to patch store fields. It also illustrates how to use the \Patch\ derive macro and manage atomic variables for ID generation.

examples/stores · high confidence

A new example application has been added to demonstrate the \\<Suspense/\>\ component behavior across different Server-Side Rendering (SSR) configurations, including 'Out-of-Order', 'In-Order', and 'Async' modes. The example includes a comprehensive routing structure with nested routes and server functions to simulate data fetching delays, allowing users to observe how suspense boundaries interact with different rendering strategies. Additionally, the example is equipped with end-to-end testing infrastructure using Playwright and Cargo Make tasks to validate these behaviors.

_examples/suspense\tests · high confidence

The examples/timer directory now includes a complete demo application that showcases the new \use\_interval\ hook. This example illustrates how to create reactive timers using fixed or dynamic intervals, allowing users to observe how the framework handles periodic updates and interval changes within a client-side rendered Rust/WASM app.

examples/timer · high confidence

The \leptos\_dom\ crate now includes a \tracing\_property\ module that enables tracing of component props when the \trace-component-props\ feature is enabled. This allows developers to inspect prop values during development via the \tracing\ ecosystem, with serialization handled for serializable types and a fallback for non-serializable ones.

_leptos\_dom/src/macro\helpers · high confidence

A new \view-tests\ example has been added to the \leptos\_dom\ crate, providing a self-contained demonstration of the reactive ownership model. The example renders various component structures, including self-updating effects, nested text interpolation, styled spans, and template consumption, allowing users to verify the rendering behavior of these patterns.

_examples/counter\_without\_macros, leptos\dom/examples/view-tests · high confidence

A new test-bench example has been added to demonstrate and benchmark the \\<For\>\ list diffing algorithm. The application renders multiple test cases that transition lists of numbers (e.g., \\[1, 2\]\ to \\[3, 2\]\) and displays the resulting DOM state, allowing users to visually verify and measure the performance of list updates and reordering.

_leptos\dom/examples/test-bench · high confidence

The SQLite-based Todo example application now includes a database migration file that creates the 'todos' table with columns for id, title, and completed status, ensuring the application's data schema is properly initialized.

_examples/todo\_app\_sqlite/migrations, examples/todo\_app\_sqlite\axum/migrations · high confidence

A new example application (\hydration-test\) has been added to demonstrate server-side rendering and client-side hydration. The server-side component (\main.rs\) uses Actix Web to stream the initial HTML view to the client, while the client-side component (\lib.rs\) includes a \hydrate\ entry point that attaches the Leptos runtime to the existing DOM. The example app itself tests hydration stability by rendering a resource that behaves differently during SSR versus client-side execution, alongside interactive inputs and signals.

_leptos\dom/examples/hydration-test · high confidence

The \tachys/src/svg\ module now provides a comprehensive set of SVG elements (such as \circle\, \path\, \g\, and \use\) that are correctly registered in the SVG namespace (\http://www.w3.org/2000/svg\). This ensures that SVG content renders with proper namespace context, fixing issues where SVG elements might have been treated as generic HTML. The implementation includes support for the \\<use\>\ element and configures child text escaping appropriately for most elements, while respecting exceptions for \script\ and \style\ tags as indicated by the broader context of the change.

tachys/src/svg · high confidence

Added a new documentation project in \projects/tauri-from-scratch\ that provides a step-by-step guide for building a Leptos application with Tauri from scratch. The entry includes the necessary configuration files (\.gitignore\, \Trunk.toml\, \tauri.conf.json\, \build.rs\) and source files (\index.html\) to demonstrate setting up a workspace with separate SSR and CSR builds, configuring Trunk for WASM bundling, and defining Tauri app metadata and build commands.

projects/tauri-from-scratch · high confidence

The leptos\_macro crate now includes a build script that automatically detects whether the compiler is the nightly channel. If nightly is detected, it sets the \rustc\_nightly\ configuration flag, enabling conditional compilation for nightly-specific features within the macro crate.

_leptos\macro · high confidence

A new example project, \login\_with\_token\_csr\_only\, has been added to demonstrate a client-side rendered (CSR) authentication flow. This example shows how to integrate with an existing API that uses token-based authentication without requiring changes to the server. It includes a Rust/Leptos client that manages login, registration, and logout states, storing the API token in local storage, and a corresponding Axum-based server that handles user creation, login, and token validation.

(repo-wide) · high confidence

The \leptos\_axum\ integration now supports execution in JavaScript-hosted WebAssembly environments (such as Deno, Cloudflare Workers, and other JS Fetch-based runtimes). To enable this, users must disable default features and enable the \wasm\ feature in their \Cargo.toml\ configuration. This change introduces a new runtime mode that allows the Axum integration to function outside of the standard native Tokio environment, expanding deployment options for Leptos applications.

integrations/axum · high confidence

The \server\_fn\_macro\_default\ crate now provides the default implementation of the \\#\[server\]\ macro, allowing users to declare server-side functions that run only when the \ssr\ feature is enabled. This macro supports named arguments for configuring the function's name, API prefix, endpoint path, input/output encoding (such as JSON or CBOR), and custom client or request/response types, automatically generating the necessary struct and routing logic.

_server\_fn/server\_fn\_macro\default · high confidence

This release introduces the \leptos\_actix\ crate, providing a first-party integration for running Leptos applications on the Actix web server. The new module exposes utilities for server-side rendering, including \render\_app\_to\_stream\ for streaming SSR, \generate\_route\_list\ for converting Leptos routes into Actix-compatible paths, and \ResponseOptions\ for allowing server functions and components to override HTTP status codes and headers. It also includes a \Request\ wrapper to access Actix request data within the Leptos context API and handles server function routing automatically.

integrations/actix · high confidence

This change introduces the first implementation of MathML elements within the Tachys framework. The new \tachys/src/mathml/mod.rs\ file defines a set of MathML tags (such as \math\, \mi\, \mo\, \mfrac\, etc.) and their specific attributes, enabling users to render mathematical notation. Each element is configured with the correct MathML namespace (\http://www.w3.org/1998/Math/MathML\) and child-escaping behavior, ensuring proper integration with the existing HTML element system.

tachys/src/mathml · high confidence

This change introduces the source code for a new Tauri application built with Leptos. The frontend (src-orig) implements a server-rendered Leptos app with a 'Hello world' server function, an Axum-based SSR server, and a CSR fallback. The native layer (src-tauri) initializes a Tauri window, loads the web view, and opens devtools in debug mode.

projects/tauri-from-scratch/src-orig, projects/tauri-from-scratch/src-tauri · high confidence

The \reactive\_graph\ crate now includes \AsyncDerived\ (arena-allocated) and \ArcAsyncDerived\ (reference-counted), which allow values to be derived from asynchronous computations that automatically re-run when their reactive sources change. Users can access the current value synchronously as an \Option\<T\>\ via \.get()\, or await the result to get the computed value once it is ready. The implementation supports tracking dependencies within the async block, integrates with Suspense for loading states, and provides a \.by\_ref()\ method to access the result by reference without cloning.

_reactive\_graph/src/computed/async\derived · high confidence

This change introduces the \leptos\_router\ crate, providing a complete routing solution for Leptos applications. It adds the \\<Router\>\, \\<Routes\>\, \\<Route\>\, \\<A\>\, and \\<Form\>\ components to enable client-side navigation, nested route definitions, and progressive enhancement for links and forms. The router supports server-side rendering (SSR) and hydration, allowing applications to render on the server and hydrate on the client. It also includes hooks like \use\_navigate\, \use\_params\, and \query\_signal\ for accessing router state and performing programmatic navigation, along with support for static site generation and view transitions.

router/src · high confidence

The new \next\_tuple\ crate provides a \NextTuple\ trait that allows users to extend existing tuples by appending a new value, returning a new tuple with the added element. This feature supports tuples of up to 26 elements and is designed with \no\_std\ compatibility, making it suitable for embedded or minimal environments.

_next\tuple · high confidence

A new \any\_spawner\ crate has been added to provide a unified interface for spawning asynchronous tasks across different runtime environments. This library allows applications to initialize a global executor (currently supporting \tokio\ and \wasm-bindgen\ via feature flags) and then spawn \Send\ or local futures using \Executor::spawn\ and \Executor::spawn\_local\ without coupling to a specific async runtime. It also includes a \tick()\ utility for testing and polling support, enabling code to remain runtime-agnostic while still leveraging the capabilities of the underlying executor.

_any\spawner/src · high confidence

A new \or\_poisoned\ crate has been added, providing an \OrPoisoned\ trait that allows users to unwrap \RwLock\ and \Mutex\ guards with a single method call. This trait replaces the need for explicit \.expect("lock poisoned")\ or \.unwrap()\ calls, offering a clearer and more distinguishable syntax for handling poisoned locks in Rust code.

_or\poisoned · high confidence

Added a new \any\_error\ crate that provides a mechanism for wrapping arbitrary errors and 'throwing' them to user-defined error hooks. This allows applications to register a global or scoped error handler via \set\_error\_hook\, enabling UI components to catch, track (via unique \ErrorId\s), and clear errors thrown from anywhere in the codebase, including within async contexts via \ErrorHookFuture\.

_any\error · high confidence

This change adds a new hot-reloading subsystem for Leptos applications, enabling live updates of \view!\ macro templates without a full page reload. It introduces a Rust-side parser (in \leptos\_hot\_reload/src\) that converts view macros into a lightweight virtual DOM structure (\LNode\) and computes diffs between the old and new templates. These diffs are emitted as patches (e.g., \ReplaceWith\, \SetText\, \InsertChild\) and applied in the browser via an embedded JavaScript patcher (\patch.js\), which locates view instances using comment markers and executes the necessary DOM mutations. This allows developers to see UI changes instantly as they edit Rust code.

_leptos\_hot\reload/src · high confidence

The \reactive\_stores\_macro\ crate now provides \\#\[derive(Store)\]\ and \\#\[derive(Patch)\]\ for structs and enums, enabling reactive state management. Users can define stores on structs (named or unnamed fields) and enums (including named and unnamed fields), with support for generics and custom patch functions. The \Patch\ derive allows in-place updates that only notify changed fields, and the \\#\[store(skip)\]\ attribute lets users exclude specific fields from reactivity.

_reactive\_stores\macro/src · high confidence

This change introduces the \reactive\_stores\ crate, providing a new primitive for managing deeply-nested reactive state. It allows you to create reactive \Store\ and \ArcStore\ wrappers around plain Rust data structures, enabling fine-grained reactivity where individual struct fields or collection items can be tracked and updated without notifying the entire parent. The implementation includes support for keyed collections (like \Vec\ and \HashMap\), \Option\ fields, and smart pointers, along with a \Patch\ macro to efficiently update stores in place and only notify fields that have actually changed.

_reactive\stores/src · high confidence

The \owner\ module now includes a new \ArcStoredValue\ type, which provides a reference-counted, non-reactive handle for any value that is \Clone\ but not \Copy\. The existing \StoredValue\ type has been refactored to wrap \ArcStoredValue\ within an arena allocator (\ArenaItem\), allowing it to store \Copy\ values efficiently while maintaining stable references. This change introduces a modular storage system (\Storage\ trait) that supports both thread-safe (\SyncStorage\) and thread-local (\LocalStorage\) storage strategies, enabling \StoredValue\ to handle non-\Send\ types in single-threaded contexts via \new\_local\.

_reactive\graph/src/owner · high confidence

This change adds the core effect execution engine to the reactive graph system. It introduces \Effect\ for asynchronous side-effects that run on the next tick (and are disabled by default on the server unless the \effects\ feature is enabled), \ImmediateEffect\ for synchronous, immediate execution (useful for strict ordering or recursion), and \RenderEffect\ for UI-driven effects that run synchronously during rendering. The implementation includes support for effect pausing/resuming, batching for atomic updates, and optional \subsecond\ hot-reloading support for render effects.

_reactive\graph/src/effect · high confidence

The \reactive\_graph/src/computed\ module now exposes \ArcMemo\ and \Memo\ for efficient, cached derived values that recompute only when dependencies change, alongside a new \Selector\ type for optimized conditional signal notifications. \ArcMemo\ provides a reference-counted, thread-safe memoization primitive, while \Memo\ offers an arena-allocated, \Copy\ variant tied to a reactive owner. The \Selector\ component allows tracking whether a source value matches specific keys, notifying subscribers only when the selection status changes, which optimizes scenarios like UI selection states.

_reactive\graph/src/computed · high confidence

The \leptos\_macro\ crate now includes implementations for the \\#\[lazy\]\ and \\#\[lazy\_preload\]\ macros, which enable code splitting and lazy loading of functions by generating unique identifiers and integrating with WASM splitting or server-side prefetching. Additionally, the \memo!\ macro is introduced to create reactive computed values from signal paths, and the \slice!\ macro allows deriving reactive slices of signal data. These additions expand the framework's capabilities for performance optimization and fine-grained reactivity.

_leptos\macro/src · high confidence

The \tachys/src/reactive\_graph\ module now provides the core infrastructure for reactive attribute rendering, enabling two-way data binding and reactive updates for classes, styles, properties, and inner HTML. This change introduces new modules (\bind\, \class\, \inner\_html\, \property\, \style\) that implement rendering traits for reactive signals and functions, allowing UI elements to automatically update when underlying data changes. It also includes a reactive \NodeRef\ for DOM node references and an \OwnedView\ wrapper for managing reactive ownership scopes, forming the foundation for the framework's reactive view system.

_tachys/src/reactive\graph · high confidence

This change introduces the Tachys library, a new statically-typed UI framework for Rust. The diff establishes the core module structure in \tachys/src\, including DOM interaction helpers (\dom.rs\), a type-erased container system (\erased.rs\) for efficient component handling, and a hydration cursor (\hydration.rs\) for managing server-side rendering state. It also defines the public API surface (\lib.rs\) with prelude traits like \RenderHtml\ and \IntoAttributeValue\, and provides initial view implementations for string types (\oco.rs\), enabling users to build reactive, type-safe user interfaces.

tachys/src · high confidence

The \tachys/src/renderer\ module now provides the core rendering infrastructure for the Tachys framework, introducing a \Renderer\ trait that defines the interface for manipulating UI trees. This change adds a concrete \Dom\ renderer that implements this trait using \web-sys\ to interact with the browser's Document Object Model, including features like a template cache and microtask queueing for performance. Additionally, a \MockDom\ renderer is provided to allow testing component logic in a pure Rust environment without a browser, and an experimental \Sledgehammer\ backend is included for optimized element creation. The \Renderer\ trait is now implemented for these backends, enabling the framework to render views on different platforms.

tachys/src/renderer · high confidence

A new \either\_of\ crate has been added to the project, providing utilities for working with enumerated types that hold one of 2 to n other types. The library is designed for \no\_std\ environments and exposes a generic enum type (generated via macros) along with a comprehensive set of methods including mapping, inspection, conversion, and iterator support for these multi-variant structures.

_either\of/src · high confidence

The \reactive\_graph\ crate is introduced as the foundational reactive system, providing fine-grained reactivity through atomic Signals, derived Computations (Memories, AsyncDerived), and Effects. This new module includes core types like \RwSignal\, \ArcSignal\, and \Callback\, along with utilities for ownership management (\Owner\), context sharing, and non-reactive zones. It also adds support for serializing reactive values via \serde\ and enables calling signals like functions on nightly Rust through \Fn\ trait implementations.

_reactive\graph/src · high confidence

The \server\_fn\_macro\ crate has been added to provide the implementation for the \\#\[server\]\ macro, enabling users to define server-side functions that are framework-agnostic. This macro parses server function arguments and body, automatically handling framework-specific requirements such as wrapping async blocks for Actix compatibility, selecting the appropriate client (Reqwest or Browser) and server backend (Axum, Actix, or Mock) based on enabled features, and managing default input/output encodings. This change establishes the core procedural macro infrastructure required for server function execution across different server environments.

_server\_fn\macro/src · high confidence

The framework now supports type-erased attributes via the new \AnyAttribute\ type, which allows attributes to be stored and manipulated dynamically (e.g., for spreading or conditional application) by boxing them into a common interface. This change introduces the \AddAnyAttr\ trait and associated macros that enable combining multiple attributes into a single \Vec\<AnyAttribute\>\ when the \erase\_components\ feature is enabled, while maintaining tuple-based composition otherwise. Additionally, the library adds comprehensive support for ARIA attributes through the \AriaAttributes\ trait, provides a \CustomAttr\ type for arbitrary key-value attributes, and exposes global HTML attributes (such as \class\, \style\, \prop\, and event listeners like \on\ and \on\_target\) directly on \HtmlElement\ via the \GlobalAttributes\ trait.

tachys/src/html/attribute · high confidence

The \hydration\_context\ crate now provides a modular \SharedContext\ trait that allows applications to store data on the server and extract the same data in the browser during hydration. This change introduces three distinct implementations: \SsrSharedContext\ for server-side rendering, \HydrateSharedContext\ for browser-side hydration (supporting both full hydration and 'islands' mode), and \CsrSharedContext\ for client-side rendering. The context manages unique data identifiers, serializes asynchronous resources and errors from server to client, and handles error boundary state to ensure stable hydration IDs and correct error propagation across the network boundary.

_hydration\context/src · high confidence

The \reactive\_graph/src/actions\ module now exposes \Action\ (and \ArcAction\) and \MultiAction\ (and \ArcMultiAction\) types, allowing users to run asynchronous code in response to dispatched values while maintaining reactive access to the input, result, pending status, and version. \Action\ handles single asynchronous calls, providing signals for \input\, \value\, \pending\, and \version\, while \MultiAction\ enables tracking multiple concurrent submissions via a \submissions\ signal. These primitives are designed for mutating or updating data reactively, distinct from data loading patterns.

_reactive\graph/src/actions · high confidence

Adds the \errors\_axum\ example, which demonstrates how Leptos error boundaries interact with an Axum backend. The example includes a custom \ErrorTemplate\ component that displays error details and sets the HTTP response status code (e.g., 404 or 500) based on the first error in the boundary. It showcases both client-side navigation errors (via non-existent routes like \/404\) and server-side errors triggered by a server function (\CauseInternalServerError\), illustrating how errors propagate from the server to the UI and affect the final HTTP response.

_examples/errors\axum · high confidence

The \examples/server\_fns\_axum\ directory has been added, providing a complete reference implementation of a Leptos application using the Axum web framework. This example demonstrates how to integrate Leptos server functions with an Axum backend, including features such as custom error handling, alternative serialization encodings (Postcard, Rkyv), file uploads with progress tracking, and middleware integration. It serves as a practical guide for users setting up server-side rendering and client-server communication in an Axum environment.

_examples/server\_fns\axum · high confidence

Added a new \todo\_app\_sqlite\_csr\ example that demonstrates client-side rendering (CSR) combined with server functions to interact with a SQLite database. The example includes the full application source code (including components for adding, listing, and deleting todos, error handling, and a fallback handler), a SQL migration for the todos table, and configuration files such as \rust-toolchain.toml\ and \Makefile.toml\ to support building and testing the example.

_examples/todo\_app\_sqlite\csr · high confidence

The \tachys/src/html\ module has been restructured to introduce a new, type-safe system for handling HTML attributes and interactivity. This change adds dedicated modules for managing CSS classes (\class.rs\), styles (\style.rs\), and DOM properties (\property.rs\), all implementing a unified \Attribute\ trait that supports asynchronous resolution and reactive rebuilding. It introduces a \Directive\ system (\directive.rs\) allowing custom client-side logic to run on element creation or hydration, and a \Targeted\ event system (\event.rs\) that provides typed access to event targets. Additionally, it implements an \Island\ component (\islands.rs\) for wrapping interactive views within inert HTML, and a \NodeRef\ attribute (\node\_ref.rs\) for obtaining references to DOM elements. These components work together to replace the previous generic rendering approach with a more robust, type-checked attribute handling model.

tachys/src/html · high confidence

The HTML element system has been restructured to introduce \ElementExt\, a trait that allows adding attributes, classes, styles, and event listeners to built DOM elements at runtime, mirroring the compile-time API. A new \custom()\ function enables the creation of typed custom HTML elements with dynamic tag names. Additionally, an \inner\_html()\ attribute is provided to set an element's inner HTML directly, with explicit security warnings regarding XSS.

tachys/src/html/element · high confidence

Adds a new example application (\hackernews\_islands\_axum\) demonstrating a Hacker News client built with Leptos Islands architecture and the Axum web framework. The implementation includes server-side API fetching for stories, users, and comments via \reqwest\, static asset serving with compression support (gzip/br) in the Axum fallback handler, and client-side hydration using \hydrate\_islands\. It showcases routing with \FlatRoutes\ and \OptionalParamSegment\, and integrates \tower-http\ compression for optimized delivery of static assets.

_examples/hackernews\_islands\axum/src · high confidence

The \hackernews\_js\_fetch\ example now provides a complete client-side routing implementation for navigating Hacker News content. It introduces dedicated route components for navigation (\Nav\), story listings (\Stories\), individual story views (\Story\), and user profiles (\User\). A key behavioral improvement in the story view is the dynamic injection of page-specific \\<Meta\>\ tags (using the story title as the description) via \leptos\_meta\, ensuring correct metadata for shared links. The example utilizes \leptos\_router\ hooks like \use\_params\_map\ and \use\_query\_map\ to manage URL state for pagination and story selection, and employs \Resource\ for async data fetching with \Suspense\ and \Transition\ for loading states.

_examples/hackernews\_js\fetch/src/routes · high confidence

Added a new \hackernews\_js\_fetch\ example demonstrating the integration of \axum-js-fetch\ with Leptos. This example features a client-side data fetching implementation that uses \gloo\_net\ for browser environments and \reqwest\ for server-side rendering (SSR), along with request abort handling via \AbortController\. It also showcases the new \OptionalParamSegment\ routing feature in the Leptos router.

_examples/hackernews\_js\fetch/src · high confidence

Added a new HackerNews demo application built with Axum that supports server-side rendering and hydration. The example demonstrates modern Leptos patterns including lazy-loaded routes for user and story pages, optional parameter segments, and a unified API layer that handles HTTP requests differently for client-side (gloo\_net) and server-side (reqwest) execution. It also includes error boundary handling and integrates with cargo-leptos for asset management.

_examples/hackernews\axum/src · high confidence

Added a new HackerNews demo application (\hackernews\_islands\_axum\) that showcases Leptos's experimental islands architecture and server-side rendering with the Axum web framework. The example includes route handlers for navigation, story listings, individual story views with comments, and user profiles, demonstrating features like \ShowLet\, \Transition\, \Suspense\, and \Suspend\ for handling asynchronous data fetching and UI states.

_examples/hackernews\_islands\axum/src/routes · high confidence

Added a new example project that demonstrates how to document Leptos server functions via an OpenAPI schema (using Utoipa) and serve the Swagger UI at /swagger-ui. The application includes server endpoints for greeting and name listing, and integrates with the OpenAI API to allow users to input natural language prompts that are translated into function calls against the documented API.

projects/openapi-openai-api-swagger-ui · high confidence

The \todo\_app\_sqlite\ example has been added, providing a complete full-stack application that demonstrates Leptos' server functions integrated with an Actix-web backend and a SQLite database. This example showcases how to define server-side logic (such as CRUD operations for todos) using the \\#\[server\]\ macro, manage state with \Resource\ and \Suspend\, and handle form submissions via \MultiActionForm\ and \ActionForm\. It also includes configuration for the Rust toolchain to ensure the WASM target is available, a Makefile for running UI tests, and standard documentation files.

_examples/todo\_app\sqlite · high confidence

Added a new example project in \projects/sso\_auth\_axum\ that demonstrates Single Sign-On (SSO) authorization using the OAuth2 Authorization Code Grant flow with Google. The project implements server-side rendering with Axum and Leptos, featuring a SQLite database for session and user management, CSRF token handling, and automatic access token refresh logic to maintain authenticated sessions.

_projects/sso\_auth\axum · high confidence

Added a new example application (\ssr\_modes\_axum\) demonstrating how to use different Server-Side Rendering modes (Synchronous, Out-of-order streaming, In-order streaming, and Async) with the Axum web framework. The example includes a full Axum router setup, a shell component, and routes that utilize \SsrMode\ attributes to control rendering behavior for different pages, such as using Async mode for posts to allow metadata to be set after data loading.

_examples/ssr\_modes\axum · high confidence

The server-side rendering module has been replaced with a new \StreamBuilder\ implementation that manages HTML streaming for single requests. This change introduces support for out-of-order streaming, allowing async content to be rendered and injected into the HTML stream independently of synchronous content, marked by specific chunk markers. It also adds capabilities for appending multiple streams, handling fallbacks for suspended views, and managing chunk IDs for client-side hydration, fundamentally changing how SSR responses are constructed and streamed to the client.

tachys/src/ssr · high confidence

Added a new example demonstrating how to integrate Tailwind CSS with Leptos and the Actix Web server. This includes the necessary Rust source files (app, lib, main), a Tailwind configuration (input.css), and build tooling (Makefile.toml, rust-toolchain.toml) to support the example.

_examples/tailwind\actix · high confidence

The \router\_macro\ crate now exposes a \path!\ procedural macro that parses string literals (e.g., \path!("/foo/:bar")\) into structured route segments (\StaticSegment\, \ParamSegment\, \OptionalParamSegment\, \WildcardSegment\). This allows users to define routes using a concise, string-based syntax that is automatically converted into the tuple-based segment structures expected by \leptos\_router\, simplifying path configuration and validation.

_router\macro/src · high confidence

Added four new scripts to streamline development workflows: \axum\_integration\_service\_mode.bat\ and \.sh\ automate building the Axum service mode integration tests; \bump.sh\ interactively detects changed member crates since the last release tag and bumps their versions (patch, minor, or major) using \cargo set-version\; and \update\_nightly.sh\ updates nightly version strings in the codebase to a specified or current date, handling cross-platform \sed\ differences.

scripts · high confidence

A new shell script, \examples/cargo-make/scripts/web-report.sh\, has been added to the repository. This tool scans the \examples\ directory for \Makefile.toml\ files and generates a report displaying the build and test configurations used by each example (such as Cargo Leptos, Deno, Playwright, or Trunk). It helps users quickly identify how different web examples are set up and which tooling is applied to them.

examples/cargo-make/scripts · high confidence

This release introduces several new components to the \leptos\ crate to enhance UI interactivity and ergonomics. The \AnimatedShow\ component allows conditional rendering with CSS-based mount/unmount animations and a configurable delay. \AttributeInterceptor\ enables components to intercept and forward received attributes to specific child elements rather than the root. \Await\ provides a convenient way to inline \async\ blocks or server functions directly in the view with \let:\ syntax, automatically handling suspense. Additionally, \ForEnumerate\ extends the existing \For\ component to provide reactive access to the current index during list iteration.

leptos/src · high confidence

A new example project, counter\_dwarf\_debug, has been added to demonstrate debugging Rust/WASM applications using DWARF source maps. This example configures the Trunk build tool with the \data-keep-debug="true"\ attribute to embed debug information in the generated WASM, enabling developers to set breakpoints and step through Rust source code directly in the browser or via VS Code. The project includes pre-configured VS Code launch and task files to streamline the debugging workflow.

_projects/counter\_dwarf\debug · high confidence

Added the \axum\_js\_ssr\ example application, which serves as a comprehensive guide for integrating client-side JavaScript libraries (specifically Highlight.js) into a Leptos application using Axum for server-side rendering. The example walks through various integration patterns—from naive script inclusion to idiomatic solutions using Leptos signals, effects, and \wasm-bindgen\—highlighting common pitfalls during hydration and providing working code for each approach.

_examples/axum\_js\ssr · high confidence

Added a new example in the \examples/spread\ directory that demonstrates how to spread dynamic sets of attributes and event handlers onto HTML elements and components using the \{..}\ syntax. The example shows creating spreadable attribute sets (including combined attributes and event handlers) and applying them to both standard DOM elements and custom components, illustrating how spread attributes are applied to all top-level elements returned by a component.

examples/spread · high confidence

Added a new example application that demonstrates how to handle errors from server actions in a form submission context. The example includes a server-side function that can simulate an error, an ActionForm component for submission, and an ErrorBoundary to catch and display any errors returned by the server action to the user.

examples/action-form-error-handling · high confidence

Added the \examples/subsecond\_hot\_patch\ directory, which provides a working example of using Leptos with Dioxus's \subsecond\ library for binary hot-patching. The example includes a minimal Rust application (\src/main.rs\) that connects to the DX CLI via \connect\_to\_hot\_patch\_messages\ and wraps the app in a closure to enable reactive view updates without full rebuilds. It also includes the necessary configuration files (\Dioxus.toml\, \Makefile.toml\, \.gitignore\), styling (\assets/main.css\), and branding assets (\assets/header.svg\) to support this experimental hot-patching workflow.

_examples/subsecond\_hot\patch · high confidence

The repository now includes four new example projects under the \projects/\ directory: \meilisearch-searchbar\ (a Leptos app demonstrating Meilisearch integration), \nginx-mpmc\ (demonstrating multi-process multi-client patterns with two sub-apps), and \ory-kratos\ (a Leptos server integrating with Ory Kratos for session management). These additions provide reference implementations for users looking to integrate Leptos with external services or specific architectural patterns.

(repo-wide) · high confidence

The server function codec module has been rewritten to support a flexible, trait-based encoding system that allows mixing and matching input and output serialization formats. This change introduces new codecs for CBOR, MessagePack, Postcard, and Bitcode (including a serde-integration variant), alongside existing support for JSON, Rkyv, Serde-lite, URL-encoded forms, and Multipart data. It also adds support for PATCH and PUT HTTP methods in addition to POST, and introduces streaming encodings (ByteStream and TextStream) for handling large data transfers over HTTP/2 or HTTP/3.

_server\fn/src/codec · high confidence

The router introduces a new horizontal matching strategy in \router/src/matching/horizontal\ that redefines how URL segments are matched against route definitions. This change adds \OptionalParamSegment\ to allow parameters that may be absent, enables \StaticSegment\ to accept enums via the new \AsPath\ trait, and implements \PossibleRouteMatch\ for \Box\ and \Arc\ to support dynamic dispatch. It also fixes several matching edge cases, such as rejecting over-long static segments, preventing partial matches on incomplete static segments, and ensuring empty strings or single slashes act as pass-through parents.

router/src/matching/horizontal · high confidence

The \examples/islands\ directory has been added to provide a reference implementation for Leptos' islands architecture. This example showcases nested islands, where an \OuterIsland\ provides context (a value of 42) that is consumed by child \InnerIsland\ components. It includes the necessary server setup using Axum, a hydration entry point, and configuration for the WASM target, serving as a practical guide for users implementing similar interactive UI patterns.

examples/islands · high confidence

The \leptos/src/hydration\ module now includes dedicated JavaScript files (\island\_script.js\, \islands\_routing.js\, \hydration\_script.js\) and a Rust component (\HydrationScripts\) that injects these scripts into the application shell. This enables the new islands mode by hydrating individual islands asynchronously using \requestIdleCallback\, supports client-side navigation within islands via a lightweight router that diffs pages and hydrates new islands on navigation, and provides auto-reload functionality for development with proper WebSocket protocol handling (WSS for HTTPS).

leptos/src/hydration · high confidence

Added a new example in \examples/islands\_router\ that showcases client-side routing behavior while relying exclusively on server rendering. The example implements a contact management app with search and delete capabilities, using \leptos\_router\ for navigation and \HydrationScripts\ configured with \islands=true\ and \islands\_router=true\ to enable the specific hydration mode. It includes a Rust toolchain configuration to ensure the WASM target is available for building the client-side bundle.

_examples/islands\router · high confidence

This change introduces the \leptos\_dom\ crate, providing foundational DOM utilities and a new logging system. It adds helper functions in \helpers.rs\ for accessing the \Window\ and \Document\ (cached for performance), manipulating DOM properties, and handling animation frames with cancelable handles. It also introduces a new \logging\ module with isomorphic macros (\log\, \warn\, \error\, \debug\_log\, etc.) that output to the browser console in WASM builds or standard stdout/stderr in server-side environments, with debug-specific variants that only activate in debug builds.

_leptos\dom/src · high confidence

Added a new \lazy\_routes\ example that demonstrates how to split the WASM bundle into multiple lazy-loaded binaries using the \--split\ build flag. The example showcases the \\#\[lazy\]\ macro for splitting individual async functions and the \LazyRoute\ trait for defining entire routes that load their view and data concurrently to avoid waterfall loading patterns. It includes end-to-end tests verifying navigation, hydration, and shared chunk behavior.

_examples/lazy\routes · high confidence

The \leptos\_config\ crate has been introduced to centralize Leptos application configuration. It defines the \LeptosOptions\ struct, which allows users to configure output names, site roots, package directories, server addresses, reload ports, and environment settings via environment variables or configuration files. The crate also introduces specific methods for generating CSS file paths (\css\_file\_path\ and \css\_path\) and includes a dedicated \LeptosConfigError\ enum for robust error handling during configuration loading.

_leptos\config/src · high confidence

The \leptos\_meta\ crate now includes dedicated components for managing document metadata and structure: \\<Html/\>\ and \\<Body/\>\ allow setting attributes on the root elements; \\<Title/\>\ manages the document title with reactive updates and formatters; \\<Meta/\>\ injects standard meta tags; \\<Link/\>\ handles link elements; \\<Stylesheet/\>\ and \HashedStylesheet\ load CSS files; and \\<Script/\>\ and \\<Style/\>\ inject inline scripts and styles. These components integrate with a new channel-based context system to ensure correct rendering order and hydration behavior for both client-side and server-side rendering.

meta/src · high confidence

The reactive graph now provides a complete set of new signal types to replace the previous implementation. This includes \ArcRwSignal\, \ArcReadSignal\, and \ArcWriteSignal\ for reference-counted, shared ownership scenarios, as well as \RwSignal\, \ReadSignal\, and \WriteSignal\ for arena-allocated, \Copy\ semantics. Additionally, a new \ArcTrigger\ and \Trigger\ type allows for data-less reactive notifications, and \ArcMappedSignal\ enables derived signals that wrap and map underlying values. These components form the core of the new modular, trait-based reactive system.

_reactive\graph/src/signal · high confidence

The \server\_fn/src/request\ module now includes dedicated request adapters for Actix (\actix.rs\), Axum (\axum.rs\), and the generic WASI target (\generic.rs\), alongside existing browser and reqwest implementations. These new files implement the \Req\ trait, enabling server functions to process HTTP requests and WebSockets natively on these specific server-side runtimes. This change expands the supported server environments for Leptos server functions, allowing developers to use Actix and Axum backends with full request parsing and WebSocket support, while also establishing a platform-agnostic baseline for WASI-compatible runtimes.

_server\fn/src/request · high confidence

The \examples/router\ directory now contains a complete, runnable demonstration of the Leptos router. This example showcases client-side navigation using the \path!\ macro, nested route structures via \ParentRoute\, and protected routes that require authentication. It also demonstrates advanced data handling with \AsyncDerived\ and \Suspend\ for loading states, context passing across the route tree, and browser View Transitions API for animated route changes. The example is configured to run via Trunk and includes Playwright end-to-end tests.

examples/router · high confidence

A new \session\_auth\_axum\ project has been added to the examples directory, providing a complete reference implementation of a Leptos Todo application secured with Axum session authentication. The example demonstrates server-side authentication using \axum-session-auth\ and \axum-session-sqlx\ backed by a SQLite database, featuring user signup, login, logout, and permission-based access control. It includes the necessary database migrations, Nix flake configuration for development, and Cargo Make build scripts to streamline running the application.

_projects/session\_auth\axum · high confidence

Added a new example application demonstrating static routing and incremental static regeneration. The example uses Leptos Router's \SsrMode::Static\ to pre-render pages, including a home page that regenerates when the \./posts\ directory changes and individual post pages that regenerate when their specific markdown source files are updated. It also includes the necessary build configuration (Cargo Make, rust-toolchain for WASM) and source code to serve these statically generated routes via an Axum backend.

_examples/static\routing · high confidence

Added a new \integrations/utils\ crate containing shared utilities for server-side rendering integrations. This includes the \ExtendResponse\ trait and \build\_response\ function, which standardize how server frameworks construct HTTP responses from Leptos apps. The implementation handles streaming chunks, manages reactive ownership cleanup, injects meta context, and supports preloading WASM split files and prefetches with proper nonce handling for CSP.

integrations/utils · high confidence

The project now includes foundational documentation and tooling to guide contributors and secure the codebase. An AI Policy clarifies expectations for AI-assisted contributions, while a Code of Conduct and detailed Contributing guide outline community standards and local CI workflows. A Security Policy provides a dedicated channel for reporting vulnerabilities. Additionally, Nix flake support has been added to streamline the development environment, and the README has been significantly expanded with badges, usage examples, and architectural context.

(repo-wide) · high confidence

The router now supports type-erased containers (\AnyNestedRoute\ and \AnyNestedMatch\) for nested routes, allowing child routes to be stored and matched without requiring static type information at the parent level. This enables more flexible routing structures where child routes can be determined or modified at runtime, such as for dynamic module loading or conditional route trees, while maintaining the ability to match paths, extract parameters, and render views.

router/src/matching/nested · high confidence

The server-side functionality has been extracted into a dedicated \leptos\_server\ crate, introducing new types for managing server interactions: \ServerAction\ and \ServerMultiAction\ for dispatching server functions, \ArcResource\ and \ArcOnceResource\ for asynchronous data loading with server-to-client serialization, \ArcLocalResource\ for client-only data, and \SharedValue\ for synchronously shared state. This separation isolates server-specific logic, including serialization codecs (via \codee\) and hydration context handling, from the core reactive graph.

_leptos\server/src · high confidence

The server\_fn\_macro crate now includes a build script that conditionally enables the rustc\_nightly configuration flag when compiling with a nightly Rust toolchain, allowing for nightly-specific features. Additionally, a Makefile.toml has been added to integrate the crate into the workspace's cargo-make task runner, extending the main configuration for consistent build automation.

_server\_fn\macro · high confidence

The reactive\_graph crate now includes a build script that conditionally sets the \rustc\_nightly\ configuration flag when compiled with a nightly Rust compiler, enabling nightly-specific features. Additionally, a Makefile configuration is introduced to extend the project's build system, and documentation is added to explain the fine-grained reactive primitives (signals, computations, and effects) and their design principles.

_reactive\graph · medium confidence

New HTML files have been added for the test-bench and view-tests examples within the leptos\_dom package. The test-bench entry point provides a standard HTML5 structure with a title, while the view-tests entry point includes a Trunk configuration to compile and link the Rust/WASM code, enabling these specific test scenarios to run in a browser.

_leptos\dom/examples · high confidence

The Leptos package now includes a \build.rs\ script and a \Makefile.toml\ to streamline the build process. The build script automatically enables the \rustc\_nightly\ configuration flag when compiling with a nightly Rust compiler and sets the \getrandom\_backend\ to \wasm\_js\ for WebAssembly targets. Additionally, the new Makefile defines a \check\ task that runs clippy and cargo checks across specific feature combinations (hydrate, csr) and targets (native, wasm32), including both debug and release modes, ensuring consistent validation during development.

leptos · high confidence

The Tachys package now includes a build script that automatically detects the Rust compiler channel and enables the \rustc\_nightly\ configuration flag when using a nightly build, ensuring features gated by this flag are correctly activated. Additionally, a Makefile configuration has been added to integrate with the project's cargo-make infrastructure, streamlining local development and CI tasks for the package.

tachys · high confidence

The server\_fn crate now conditionally enables specific trybuild tests only when built with a nightly Rust compiler. A new build script detects the Rust release channel and sets a configuration flag, ensuring that these tests do not run or fail on stable or beta toolchains.

_server\fn · high confidence

The counter example has been refactored to adopt the new reactive ownership model, removing the explicit \cx\/\Scope\ context in favor of a simpler API. The component now uses \signal()\ directly and demonstrates the new \.write()\ method for mutable updates (e.g., \\*set\_value.write() -= step\). Additionally, the example now includes \console\_error\_panic\_hook\ and \console\_log\ for better debugging, and is structured with a dedicated \Makefile.toml\ and \rust-toolchain.toml\ to support standard build and test tasks.

examples/counter · high confidence

The example library now includes a TestComponent that showcases how Rust and view code blocks are documented in property comments, including examples with syntax highlighting and compile-fail markers, alongside a TestMutCallback component that illustrates the use of mutable callbacks in component props.

_leptos\macro/example · high confidence

The Hackernews Axum example has been updated to use the framework's new lazy routing system, where route components implement the \LazyRoute\ trait to separate data fetching (via \Resource\) from view rendering. This change introduces \Suspend\ and \Suspend::new()\ for handling async data within the view tree, replaces the previous \cx\/\Scope\ argument pattern with a reactive ownership model, and utilizes \ShowLet\ for cleaner conditional rendering of user data. Users will see improved performance through lazy loading of route data and a more modern, reactive component structure.

_examples/hackernews\axum/src/routes · high confidence

The Hackernews example has been rewritten to support Server-Side Rendering (SSR) alongside Client-Side Rendering (CSR). It now uses the new \leptos\_router\ API, including \OptionalParamSegment\ and \RoutingProgress\ for async data loading indicators. The application structure includes a dedicated API module (\api.rs\) that handles HTTP requests differently for SSR (using \reqwest\) and CSR (using \gloo\_net\ with abort controller support for cleanup). The server entry point (\main.rs\) is configured with Actix-web to serve the app and static assets, while the client entry point handles hydration.

examples/hackernews/src · high confidence

The Hackernews example routes have been rewritten to adopt the latest Leptos reactive ownership model and rendering patterns. Navigation and story listing now utilize the \\<A\>\ component for client-side routing, while data fetching relies on \Resource\ combined with \\<Suspense\>\ and \\<Transition\>\ components to manage loading states and fallbacks. The implementation also incorporates \ShowLet\ for cleaner user data handling and \Suspend::new\ within suspense boundaries to handle async view generation, replacing older patterns like explicit \cx\/\Scope\ passing and manual pending signals.

examples/hackernews/src/routes · high confidence

Server functions are now decoupled from specific web frameworks via new \Client\ and \Server\ traits, allowing the core logic to run on non-web platforms (like WASI) and supporting alternative HTTP crates. The error model has been updated to allow any type implementing \FromServerFnError\ as a return type, replacing the previous rigid \ServerFnError\ requirement, while deprecated legacy wrappers remain for backward compatibility. Additionally, a new \redirect.rs\ module provides a \REDIRECT\_HEADER\ mechanism and a configurable \RedirectHook\ to handle cross-origin redirects and form submissions without relying on standard HTTP 3xx status codes that browsers would follow immediately.

_server\fn/src · high confidence

The view rendering layer has been restructured to support a new \AnyView\ type-erased view system, enabling recursive components and dynamic control flow that was previously difficult with static typing. This change introduces \ErrorBoundary\ and \Result\ rendering to handle failures gracefully, replacing the older \TryCatch\ model. It also adds \AddAnyAttr\ support across various view types (including \Either\, \Option\, \Vec\, and \Keyed\ lists) to allow attribute spreading on complex structures, and implements \IntoFragment\ for converting various collections into type-erased view fragments. Additionally, the \islands\ feature now supports serializable keys for keyed lists to facilitate client-side navigation in islands mode.

tachys/src/view · high confidence

This change adds a new middleware abstraction in \server\_fn/src/middleware\ that standardizes how server function errors are converted into HTTP responses for both Axum and Actix integrations. By defining a common \Service\ trait and \BoxedService\ wrapper, the library now ensures consistent error serialization across frameworks, allowing middleware to intercept and handle errors uniformly. The implementation supports running Axum and Actix without default features, enabling more flexible dependency management for WASM or minimal builds.

_server\fn/src/middleware · high confidence

The internal implementation of the \view!\ macro has been restructured into a modular architecture, splitting the logic into dedicated modules for component building (\component\_builder.rs\), slot handling (\slot\_helper.rs\), and utilities (\utils.rs\). This refactoring introduces support for the \nostrip:\ prefix to pass \Option\<T\>\ props directly, enables the \clone:\ syntax for component attributes, and improves the handling of attribute spreading and dynamic class/style sorting. It also adds snapshot tests to verify the generated token streams for component rendering.

_leptos\macro/src/view · high confidence

The tailwind\_axum example has been updated to use Tailwind CSS v4. This change simplifies the CSS configuration by replacing the previous Tailwind 3 setup with a single \@import "tailwindcss"\ directive in \input.css\. The example also includes updated Rust code for the Axum server integration and a new README section documenting the migration path for users upgrading from Tailwind 3.

_examples/tailwind\axum · high confidence

The \server\_fn/src/response\ module has been restructured to introduce a unified response abstraction (\Res\, \TryRes\, \ClientRes\) that standardizes how server function results are handled across different integrations. This change adds specific implementations for Actix (\actix.rs\), Axum (\http.rs\), the browser (\browser.rs\), and the \reqwest\ client (\reqwest.rs\), alongside a platform-agnostic generic implementation (\generic.rs\). For users, this means server function responses are now consistently managed through these traits, enabling better support for streaming bodies, standardized error handling with \Content-Type\ headers, and unified redirect logic across server-side frameworks and client-side fetch operations.

_server\fn/src/response · high confidence

The reactive graph subsystem now exposes its foundational components as public, modular traits and types. Users can interact with the \ReactiveNode\ trait to manage node states (Clean, Check, Dirty) and trigger updates via \mark\_dirty\ or \mark\_check\. The system uses \Source\ and \Subscriber\ traits to define the relationship between reactive values and their dependents, with \AnySource\ and \AnySubscriber\ providing type-erased handles for efficient storage and iteration. Tracking is managed via a thread-local \Observer\ context, which allows code to run in an untracked state using the \untrack\ function, isolating parts of the reactive graph from automatic dependency collection.

_reactive\graph/src/graph · high confidence

The router's location logic has been restructured into dedicated modules (\history.rs\, \server.rs\, and \mod.rs\) introducing a unified \Url\ struct and distinct \BrowserUrl\ and \RequestUrl\ implementations. This change centralizes URL parsing and state management, adding a warning when reading the hash on the server to prevent hydration errors, and implementing robust history stack tracking that correctly handles back/forward navigation and prevents duplicate URL entries. It also introduces server-side support for propagating \ServerActionError\ via URL search parameters.

router/src/location · high confidence

The router now uses a centralized cargo-make configuration via a new Makefile.toml that extends the main workspace build file. Additionally, a build script (build.rs) has been added to automatically define the 'rustc\_nightly' configuration flag when the compiler is in the Nightly channel, enabling conditional compilation for nightly-specific features.

router · high confidence

The router's internal matching system has been completely restructured to support type-erased view resolution and more flexible path segment handling. The new \ChooseView\ trait and its \AnyChooseView\ type-erased wrapper allow route views to be resolved and preloaded without requiring static type knowledge at the matching stage, enabling better integration with lazy loading and bundle splitting. Path matching now explicitly supports \OptionalParam\ segments, which are expanded into multiple static and parameterized variants during route generation to ensure correct matching behavior. Additionally, the \resolve\_path\ utility has been updated to correctly handle scheme detection and path normalization, improving how relative and absolute paths are resolved against a base URL.

router/src/matching · high confidence

Add end-to-end tests for the SQLite Todo example; Added Playwright end-to-end tests for Tailwind examples; Added Playwright end-to-end tests for client-side navigation; Added Playwright end-to-end tests for the router example; Added SSR tests for chained resources and class attribute handling; Added UI tests for macro diagnostics; Added browser-based integration tests for the counter example; Added browser-based test for directives example; Added compile-time tests for server function return types; Added comprehensive macro tests for component, memo, slice, params, and server features; Added comprehensive test coverage for executor initialization and spawning; Added end-to-end testing for the CSR Todo App example; Added end-to-end tests for the Error Boundary example; Added end-to-end tests for the Suspense examples application; Added end-to-end tests for the suspense example app; Added integration tests for the Portal example; Added test coverage for reactive graph core primitives; Added tests for Axum service mode configurations; Added tests for Leptos configuration loading; Added tests for path macro parsing and lazy\_route diagnostics; Added tests for slice! macro error handling; Added trybuild tests for server macro aliased Result support; Added unit and integration tests for the counter\_without\_macros example; End-to-end testing for the Todo App example; New regression test suite for Leptos integration issues; Restored Playwright end-to-end tests for the counters example.

The project now includes a \Cargo.lock\ file to ensure reproducible builds, alongside a root \Cargo.toml\ that defines the workspace structure, sets the Rust edition to 2021, and establishes a Minimum Supported Rust Version (MSRV) of 1.88. This commit introduces the unified dependency definitions for the entire workspace, specifying versions for core framework crates (such as \leptos\ 0.8.21, \tachys\ 0.2.19, and \server\_fn\ 0.8.13) and external libraries (including \axum\ 0.8, \actix-web\ 4.12, and \tokio\ 1.49), while also configuring release profile optimizations like LTO and codegen-units.

(dependencies) · high confidence

An empty .gitkeep file was added to the examples/server\_fns\_axum/watched\_files directory to ensure the folder is tracked in version control. This serves as a structural placeholder for the example code, though no functional logic or error logging implementation is visible in this specific diff.

_examples/server\_fns\_axum/watched\files · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 36 → 54 (+17.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 39 → 37 (-2.1)
• Architecture 99 (new)
• Maturity 73 → 74 (+0.4)
• Readiness 23 → 58 (+35.1)
• Security 55 → 72 (+16.8)
• Domain Modelling 91 (new)

• Decision is a link to documentation rather than an explicit decision statement; no context and no consequences (docs/book/src/view/04_iteration.md)
• Decision is a link to documentation rather than an explicit decision statement; no context and no consequences (docs/book_ru/src/view/04_iteration.md)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (leptos/tests/test_examples/suspense-tests/Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High CVE: [GHSA redacted] (leptos/tests/test_examples/suspense-tests/Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (server_fn/Cargo.lock)
• High IaC: DS-0002 (examples/hackernews_islands_axum/Dockerfile)
• …and 139 more

• (anonymous)::hydrateIslands::traverse (cognitive 20) (leptos/src/hydration/island_script.js)
• ActixRequest::try_into_websocket (cognitive 19) (server_fn/src/request/actix.rs)
• AnyView::to_html_async_with_buf (cognitive 28) (tachys/src/view/any_view.rs)
• AnyView::to_html_async_with_buf (cyclomatic 16) (tachys/src/view/any_view.rs)
• Boundary-crossing change coupling: error_boundary.rs ↔ error_boundary.rs (leptos/src/error_boundary.rs)
• CI installs an unverified third-party binary (.github/workflows/publish-book.yml)
• Change coupling: action.rs ↔ multi_action.rs (leptos_server/src/action.rs)
• Change coupling: class.rs ↔ style.rs (tachys/src/reactive_graph/class.rs)
• Change coupling: hydrate.rs ↔ ssr.rs (hydration_context/src/hydrate.rs)
• Change coupling: memo.rs ↔ rw.rs (reactive_graph/src/computed/memo.rs)
• Change coupling: ssr.rs ↔ mod.rs (benchmarks/src/ssr.rs)
• ClassTooLong: FlatRoutesView (router/src/flat_router.rs)
• ClassTooLong: ServerFnCall (server_fn_macro/src/lib.rs)
• Dependency source pinned to a moving git ref
• Dom::add_event_listener_delegated (cognitive 24) (tachys/src/renderer/dom.rs)
• Duplicated block (10 lines × 2) (integrations/actix/src/lib.rs)
• Duplicated block (10 lines × 2) (leptos/src/suspense_component.rs)
• Duplicated block (10 lines × 2) (projects/openapi-openai-api-swagger-ui/src/open_ai.rs)
• Duplicated block (10 lines × 2) (reactive_graph/src/effect/render_effect.rs)
• Duplicated block (10 lines × 2) (router/src/components.rs)
• …and 464 more

• 26 commits — 12 feature/other, 14 fixes

• (repo) — 4 commits
• .github/workflows — 3 commits
• (root) — 2 commits
• leptos/src — 2 commits
• leptos_macro/src — 2 commits
• reactive_graph/src — 2 commits
• router_macro/tests — 2 commits
• tachys/src — 2 commits
• examples/cargo-make — 1 commit
• examples/counters — 1 commit
• examples/islands_router — 1 commit
• examples/regression — 1 commit
• integrations/utils — 1 commit
• reactive_stores/src — 1 commit
• router/src — 1 commit

• fix: Assorted islands-router fixes (#4855)
• fix: Fix two concurrency issues with Suspense (#4853)
• fix: Merge pull request #4844 from Ofenhed/nonce-bug
• fix: chore: regression tests
• fix: fix(leptos_macro): satisfy doc comment clippy lints
• fix: fix(reactive_graph): ignore dropped local-resource listener (#4856)
• fix: fix: break loop if markers are unmatched
• fix: fix: check for resource reads inside attribute values (see #4856) (#4859)
• fix: fix: don't moved closing markers into the other document, breaking further diffing; update them instead
• fix: fix: don't panic in the wasm-split prefetch machinery when its lock is unavailable (#4830)
• fix: fix: hydrate <For> children in the same order we SSR them (closes #4881) (#4882)
• fix: fix: include path in branch marker (otherwise, markers are identical due to component erasure)
• fix: fix: reset hydration marker to NextChild after closing branch markers
• fix: fix: stale UnsyncCallback/Callback comments
• change: Merge pull request #4862 from larstobi/replace-proc-macro-error2-with-syn
• change: Migrate leptos_macro diagnostics to syn
• change: Migrate leptos_router_macro diagnostics to syn
• change: Migrate reactive_stores_macro diagnostics to syn
• change: chore(ci): use locked dependencies when installing Trunk (#4877)
• change: chore(deps): bump actions-rust-lang/setup-rust-toolchain from 1 to 2 (#4876)
• …and 6 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

leptos-rs/leptos was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.