DioxusLabs/dioxus

This system is a Rust-based framework for building cross-platform user interfaces, supporting web, desktop, and mobile targets through a unified Virtual DOM and RSX templating syntax. It provides a full-stack development environment with features like server-side rendering, real-time WebSocket updates, and sub-second hot-reloading via binary patching. The framework includes a comprehensive CLI for building and bundling applications, along with a suite of examples demonstrating state management, routing, and native platform integrations.

42 changes.

This period focused on a comprehensive architectural overhaul for version 0.7, introducing a new component model, type-safe HTML abstractions, and a unified launch API across web, desktop, and mobile platforms. It established foundational infrastructure including a new CLI, template-based SSR, and a LiveView system, while removing legacy virtual DOM and validation packages. The release also delivered key features such as a new router, async hooks, and extensive tooling for development and formatting.

59 changes.

This period focused on establishing a comprehensive full-stack framework by introducing the dioxus-fullstack package, rewriting the CLI to support server builds and hot-patching, and implementing streaming Suspense boundaries. Significant architectural changes included restructuring the signals and generational-box systems for better memory safety, and replacing the JavaScript interpreter with a modular TypeScript implementation to improve event handling and hydration.

38 changes.

This period focused on establishing a new native rendering backend for Dioxus and introducing a granular reactive state management system via the Store macro. It also expanded the fullstack capabilities with advanced server functions, improved hot-reloading infrastructure, and a comprehensive suite of cross-platform examples and CLI tooling.

Introduces a new Hacker News client example within the app demos directory. The application fetches top stories and comments from the Hacker News API, displaying them in a split-view layout with a story list and a detail preview. It includes custom CSS for a loading spinner, implements client-side routing for story previews, and utilizes server-side streaming configuration for optimized data loading.

examples/01-app-demos/hackernews · high confidence

This location introduces a new fullstack e-commerce demo application. It features a homepage that statically renders a list of products fetched from the FakeStoreAPI, and a product detail page that uses LiveView for dynamic interaction. The app is styled with Tailwind CSS (v4.1.0) and includes a loading spinner component for suspense boundaries. Key components include a responsive navigation bar, product item cards, and a product detail view with quantity and size selectors.

examples/01-app-demos/ecommerce-site · high confidence

Introduces a new example application in examples/01-app-demos/file-explorer that demonstrates a Dioxus desktop app leveraging system calls to explore the local file system. The implementation uses a single signal to manage state, allowing users to navigate directories and view file listings, with a specific fix to prevent attempting to enter files as if they were directories.

examples/01-app-demos/file-explorer · high confidence

A new private hook, \use\_router\_internal\, has been added to the router utilities. This hook allows components to subscribe to the router context, returning the context if the component is a descendant of a Router, or None otherwise. It is designed to reduce redundancy in other components and hooks by providing a safe, reusable way to access router state, though multiple subscriptions within a single component are discouraged.

packages/router/src/utils · high confidence

The Dioxus-web package now includes a build script that automatically generates JavaScript bindings from TypeScript sources, ensuring the generated code stays in sync with source changes. Additionally, a README file has been added to provide an overview of the package's capabilities, such as WebAssembly support and hot reloading, along with contributing guidelines and license information.

packages/web · high confidence

Users can now host LiveView applications using the Axum web framework. This change introduces a new \axum\_adapter\ module that implements the \LiveviewRouter\ trait, allowing developers to register LiveView WebSocket routes and serve the necessary HTML glue code directly within an Axum router. The adapter handles the conversion between Axum WebSocket messages and the LiveView socket interface, enabling seamless integration of LiveView into Axum-based servers.

packages/liveview/src/adapters · high confidence

The CLI has been rewritten to support fullstack applications, introducing new subcommands including \dx build\, \dx bundle\, \dx check\, \dx component\, \dx config\, \dx create\, \dx doctor\, and \dx hotpatch\. The \dx build\ command now handles both client and server builds, with automatic detection of fullstack mode and support for static site generation (SSG). The \dx bundle\ command consolidates bundling logic, supporting various package types and output directories. The \dx check\ command provides linting capabilities, while \dx component\ manages component registries. The \dx config\ command allows configuration of CLI settings, and \dx create\ simplifies project creation with template support. The \dx doctor\ command performs system analysis to verify installation correctness, and \dx hotpatch\ enables binary patching for hot-reloading.

packages/cli/src/cli · high confidence

The CLI now includes a static analysis check that detects invalid hook usage patterns in Dioxus components, such as calling hooks inside conditionals, loops, closures, or async blocks, and outside of component functions. Additionally, the CLI's build script has been updated to reliably embed the current git commit SHA into the binary by checking environment variables, Cargo's VCS info, and the local git repository, ensuring accurate version reporting even when installed from crates.io.

packages/cli · high confidence

The CLI now provides Handlebars-based templates for generating Info.plist files for iOS and macOS targets, allowing users to customize metadata and permissions via Dioxus.toml. These templates support dynamic injection of display names, bundle identifiers, and version strings, while also enabling configuration of permission usage descriptions, URL schemes, background modes, and raw plist entries directly from the configuration file.

packages/cli/assets/ios · high confidence

The \packages/core-macro/src/props\ module has been introduced to provide the \Props\ derive macro, which generates a builder pattern for component properties. This implementation adapts the \rust-typed-builder\ crate to Dioxus, automatically implementing \Into\<Option\>\ for setters and defaulting optional fields to \None\. It supports named structs while explicitly rejecting tuple structs, enums, and unions, and includes logic for handling required fields, default values, and extension fields.

packages/core-macro/src/props · high confidence

The \dioxus-desktop\ package is introduced, providing a webview-based desktop renderer for the Dioxus VirtualDom. The package includes a new README with setup instructions and links to version 0.7 documentation, a \build.rs\ script that warns about GNU Windows target limitations in Wry and copies workspace assets for documentation scraping, and a TypeScript configuration for native evaluation bindings.

packages/desktop · high confidence

This change introduces the Dioxus VS Code extension, providing features such as auto-formatting RSX, converting HTML to RSX, and converting HTML to Dioxus components. The package includes the necessary build configuration (webpack, TypeScript, ESLint) and documentation to support these editor integrations.

packages/extension · high confidence

The Dioxus VS Code extension is now available, providing native support for formatting and translating Dioxus RSX code. It integrates a WebAssembly-based formatter that respects VS Code's indentation settings (tabs vs. spaces and tab size) and supports formatting on save, full-document formatting, and formatting of specific selections. Additionally, it includes commands to translate selected HTML fragments into Dioxus RSX components or standard RSX blocks, enhancing the developer experience for Dioxus projects within VS Code.

packages/extension/src · high confidence

This change adds the \dioxus\_liveview\ crate, enabling developers to run Dioxus applications on a server and stream updates to the browser via WebSockets. It provides a server-side configuration and launch system (defaulting to Axum), a document abstraction for managing head elements and JavaScript evaluation, and a query engine that allows Rust code to execute JavaScript and retrieve results asynchronously. The implementation includes a WebSocket event loop that handles initial renders, user input, and hot-reloading, along with a client-side JavaScript interpreter that bridges the browser DOM with the server's VirtualDom.

packages/liveview/src · high confidence

A new \packages/native\ crate is added, providing a native renderer for Dioxus applications. This backend integrates with the \winit\ windowing library and supports multiple rendering backends (Vello, Skia, Vello CPU) via feature flags. It introduces a native-specific configuration system (\Config\) for window attributes and font contexts, a document implementation for managing head elements, and a network provider for asset resolution. The package also exposes native-specific hooks like \use\_window\_event\ and \use\_back\_button\, and includes a prelude module to simplify imports for developers building native apps.

packages/native · high confidence

The \packages/router/src\ directory now contains the core implementation of the Dioxus Router, providing a complete routing solution for Dioxus applications. Users can now define routes using the \Routable\ derive macro and navigate programmatically via the new \use\_router\, \use\_route\, and \use\_navigator\ hooks. The package exposes key UI components including \Router\ for setting up the routing context, \Link\ for declarative navigation, \Outlet\ for nested route rendering, and \HistoryButton\ components for browser history control. It also supports external navigation targets, query parameter parsing via \FromQueryArgument\, and configurable error handling through \RouterConfig\.

packages/router/src · high confidence

Added the \rsx-rosetta\ crate, which provides functions to convert an HTML DOM tree into a Dioxus RSX \CallBody\. This allows users to translate static HTML markup into RSX components, including handling element mapping, attribute normalization, and automatic extraction of SVG elements into separate components.

packages/rsx-rosetta/src · high confidence

This change introduces a new \wasm-split\ workspace that enables splitting WebAssembly binaries into multiple chunks for lazy loading on demand. It adds a CLI tool (\wasm-split-cli\) to analyze call graphs and emit split modules, a Rust runtime (\wasm-split\) with \LazyLoader\ and \LazySplitLoader\ types for managing asynchronous chunk loading, and procedural macros (\wasm-split-macro\) to generate the necessary loader code for async functions. A helper crate (\wasm-used\) is also included to debug which symbols are retained in the binary, aiding in size optimization.

packages/wasm-split · high confidence

Added new \WebDioxusChannel\ classes in \packages/web/src/js/eval.js\ and \packages/web/src/ts/eval.ts\ to handle message passing between JavaScript and Rust. These classes implement a channel-based communication pattern using \Channel\ instances for bidirectional data flow (\js\_to\_rust\ and \rust\_to\_js\), supporting weak references via \WeakDioxusChannel\ to manage memory and lifecycle, and exposing methods for sending, receiving, and closing channels.

packages/web/src/js, packages/web/src/ts · high confidence

This change adds the \packages/component-manifest\ library, which defines the data structures for describing Dioxus components (including names, dependencies, and members) and generates their JSON schema. It also provides a helper method to construct \cargo add\ commands for component dependencies, enabling the DX components command to programmatically manage crate installations based on the manifest.

packages/component-manifest · high confidence

The \const-serialize-macro\ package now provides a \SerializeConst\ derive macro that generates compile-time serialization logic for structs and enums. Users can apply \\#\[derive(SerializeConst)\]\ to generate \MEMORY\_LAYOUT\ constants describing the memory layout of types, supporting named and unnamed struct fields, unit structs, and enums with explicit \repr\ attributes (C or integer types). The macro allows specifying a custom crate path via the \\#\[const\_serialize(crate = ...)\]\ attribute to resolve serialization traits.

packages/const-serialize-macro · high confidence

The \packages/asset-resolver\ crate now provides a unified API for resolving and reading static assets across different deployment targets. For native platforms (macOS, Windows, Linux, Android), assets are resolved from the local bundle structure (e.g., \Resources\ on macOS, \lib/\ on Linux) or the Android AssetManager, with specific logic to handle Linux bundle paths correctly. For web/WASM targets, assets are fetched via HTTP requests. The crate exposes \read\_asset\_bytes\ for cross-platform byte access and \asset\_path\ for desktop-specific path resolution, allowing applications to bundle and access static files like JSON or images consistently regardless of the runtime environment.

packages/asset-resolver · high confidence

The \dioxus-fullstack\ crate is introduced, providing the core infrastructure for full-stack server functions. This includes a new client module (\client.rs\) for constructing HTTP requests and managing server URLs, an encoding module (\encoding.rs\) supporting JSON, CBOR, Postcard, and MsgPack serialization, and a \lazy.rs\ module for thread-safe, lazily-initialized global variables. The package also exports payload handling, request/response traits (\IntoRequest\, \FromResponse\), and re-exports key dependencies like \axum\, \reqwest\, and \http\ for convenience.

packages/fullstack/src · high confidence

A new \dioxus-fullstack-core\ crate has been added to provide the foundational types, traits, hooks, and contexts for \dioxus-fullstack\. This library is designed for integrators who need to work with the fullstack renderer but want to avoid the overhead of the full crate, resulting in quicker build times. It exposes core functionality such as \use\_server\_future\ and \use\_loader\ for server-side data fetching, \FullstackWebDocument\ for client-side document handling, and robust error handling via \ServerFnError\ and \HttpError\ types that support custom HTTP status codes and serialization.

packages/fullstack-core · high confidence

The new \packages/document\ crate provides a \Document\ trait and a \NoOpDocument\ implementation to abstract platform-specific document operations such as setting the title, creating head elements (meta, script, style, link), and evaluating JavaScript. It exposes a \document()\ helper to retrieve the current platform's document context and an \eval()\ function to run JavaScript, returning an \Eval\ object that supports awaiting results, sending messages, and receiving data. This change establishes the foundational API for document manipulation and JS interop, replacing previous ad-hoc implementations with a unified, context-based provider.

packages/document/src · high confidence

The \packages/signals/src/global\ module now provides \GlobalSignal\ and \GlobalMemo\ types, allowing developers to create and access reactive state from anywhere in the application without explicit prop-drilling or context passing. These global instances are lazily initialized once per application lifecycle and automatically resolve to the current virtual DOM's state, ensuring consistency across the UI tree.

packages/signals/src/global · high confidence

The \packages/native-dom\ crate now provides the core headless native renderer for Dioxus, integrating the \VirtualDom\ with the \Blitz\ document model. This change introduces the \DioxusDocument\ struct to manage the document lifecycle, a \NativeConverter\ to map platform events (such as keyboard, pointer, and scroll) to Dioxus events, and a \StackWriter\ to handle DOM mutations. It also adds support for custom widget attributes and synthetic event generation, establishing the foundation for native UI rendering.

packages/native-dom · high confidence

The fullstack server now supports incremental static rendering (ISR) to cache and serve pre-rendered HTML, improving performance for heavy routes. Users can configure this via \ServeConfig::incremental()\, which allows setting a static directory, memory cache limits, and cache invalidation times. Additionally, the server now manages the HTML document head (title, meta, link, script, style) during SSR, ensuring these elements are correctly injected and hydrated on the client. The server also parses and handles \index.html\ files from the public directory, supporting custom root IDs and SSR-only modes.

packages/fullstack-server/src · high confidence

The config-macro package now provides procedural macros that conditionally compile code based on the target platform. Users can utilize macros such as \server\_only\, \client\, \web\, \desktop\, \native\, \mobile\, \fullstack\, \ssr\, and \liveview\ to include or exclude code blocks depending on enabled features, enabling cleaner cross-platform application logic.

packages/config-macro/src · high confidence

The \packages/stores\ crate has been added, providing a new \Store\ type designed for reactive, nested data structures. This feature allows users to derive stores from their data structs, enabling granular reactivity where UI components only re-render when the specific parts of the data they depend on change. The implementation includes a subscription tree system to track dependencies and mark nodes dirty efficiently, supporting features like vec index tracking and hashed child scopes.

packages/stores/src · high confidence

The dx-wire-format package now defines a \StructuredOutput\ enum that standardizes CLI logs into parseable JSON, allowing third-party tools to reliably consume command results. This format includes specific variants for build stages (\BuildStage\), hotpatching events, cargo/rustc diagnostics, and final success or error states, ensuring that the last line of output indicates command completion. Additionally, it exposes \StructuredBuildArtifacts\ to provide detailed metadata about build outputs, including paths, environment variables, and bundled assets.

packages/dx-wire-format · high confidence

The Dioxus CLI now collects anonymous telemetry data to help improve tooling quality and track performance. This includes sending a heartbeat on CLI execution to track version distribution and critical launch failures, as well as periodic rollups of logs covering command usage, build performance, and crash details (including stack frames). The implementation collects minimal data such as the system target triple, a session ID, and a distinct installation ID, while explicitly avoiding PII. Users can disable this telemetry via the 'disable-telemetry' feature flag, the TELEMETRY=false environment variable, or the 'dx config set disable-telemetry true' command.

packages/cli-telemetry · high confidence

Adds the Subsecond library, which enables hot-patching for Rust applications by detouring function calls through a jump table, allowing code changes to be applied without restarting the process. The package includes the core library implementation, typed pointer types for patch management, and test harnesses for cross-crate thread-local storage to ensure stability during binary patching.

packages/subsecond · high confidence

The core library now includes a new \SuspenseBoundary\ component and associated runtime logic in \packages/core/src/suspense\. This feature allows applications to render placeholder content while child components await asynchronous data. The implementation supports server-side streaming, where placeholders are sent to the client first and resolved content is streamed in, as well as client-side hydration of these placeholders. It introduces specific APIs like \SuspenseContext\ and \SuspendedFuture\ to manage suspended tasks and boundary states.

packages/core/src/suspense · high confidence

The \fullstack-macro\ package now provides specific procedural macros for HTTP methods (\\#\[get\]\, \\#\[post\]\, \\#\[put\]\, \\#\[delete\]\, \\#\[patch\]\) in addition to the existing \\#\[server\]\ macro. These new macros allow developers to explicitly define the HTTP verb for a server function endpoint, simplifying the creation of RESTful APIs by removing the need to manually configure the method within the \\#\[server\]\ attribute.

packages/fullstack-macro · high confidence

The \lazy-js-bundle\ package now provides a Rust-based builder that generates TypeScript bindings into JavaScript. It supports configurable minification levels (none, whitespace, syntax, or identifiers) and implements an incremental build strategy: it hashes input \.ts\/\.js\ files and skips regeneration if the hash matches the previous run, ensuring fast rebuilds during development. The tool relies on the \bun\ CLI for the actual bundling and will fail the build if \bun\ is not installed or if the bundling process fails.

packages/lazy-js-bundle · high confidence

The core-macro crate now provides a new \#\[component\] procedural attribute and a Props derive macro. The \#\[component\] attribute transforms annotated functions into components by generating a corresponding Props struct (unless explicit props or struct patterns are used), handling lazy loading options, and supporting completion hints. The Props derive macro generates the necessary trait implementations for component properties. This replaces previous component definition mechanisms with a more structured, macro-driven approach that integrates with the RSX parser.

packages/core-macro/src · high confidence

Added two new example applications in the LiveView package demonstrating integration with the Axum web framework. The \axum.rs\ example shows a basic setup using \LiveviewRouter\ to serve a simple interactive component, while \axum\_stress.rs\ provides a high-load test case using \LiveViewPool\ and WebSocket upgrades to handle rapid state updates across many DOM nodes.

packages/liveview/examples · high confidence

Added a comprehensive set of new examples in the \examples/02-building-ui\ and \examples/04-managing-state\ directories. The UI section demonstrates core rendering concepts including components, children, conditional rendering, lists, event handling, forms, and SVG. The state management section covers reactive primitives like signals, memos, and effects, as well as patterns for sharing state via context, global signals, lifting state, and reducers.

examples/02-building-ui, examples/04-managing-state · high confidence

Added a new example in \packages/rsx-rosetta/examples/html.rs\ that demonstrates how to parse raw HTML strings into a DOM tree and convert them into Dioxus RSX code using \dioxus\_rsx\_rosetta::rsx\_from\_html\ and \dioxus\_autofmt::write\_block\_out\. This provides a concrete usage pattern for users looking to migrate or convert existing HTML markup into RSX format.

packages/rsx-rosetta/examples · high confidence

Adds the HotDog example application, a Dioxus full-stack demo that fetches random dog images from the Dog CEO API and allows users to save them to a favorites list. The app includes a web-based UI with navigation between the main view and a favorites page, styled with custom CSS. It uses a Rust backend (backend.rs) with an in-memory SQLite database to persist saved dog image URLs, exposing REST endpoints for listing, saving, and deleting favorites. The project is configured for deployment via Fly.io (fly.toml) and includes a Dockerfile for containerized runtime, along with a .gitignore to exclude the local database file.

examples/01-app-demos/hotdog · high confidence

Added two new examples to the integrations directory: a Progressive Web App (PWA) template that demonstrates service worker registration, caching, and offline capabilities via a manifest and custom HTML, and a Tailwind CSS example showing how to configure the framework with automatic watcher initialization in Dioxus 0.7.

examples/10-integrations · high confidence

The \packages/stores-macro\ crate now provides the \\#\[derive(Store)\]\ macro and the \\#\[store\]\ attribute macro to enable reactive state management. The derive macro generates an extension trait and a transposed struct/enum for types, allowing users to access individual fields or variants as scoped stores (e.g., \store.checked()\) and to destructure stores via a \transpose()\ method. The \\#\[store\]\ attribute allows adding methods to existing \Store\<T\>\ implementations, automatically inferring \Readable\ or \Writable\ bounds based on method signatures. Both macros enforce visibility constraints using witness types to ensure generated accessors respect the original field or method visibility.

packages/stores-macro · high confidence

The examples/01-app-demos directory has been refreshed with a suite of new and revised demo applications. This includes a new calculator example (calculator.rs) that uses closures for state management, alongside an existing mutable-state variant (calculator\_mutable.rs). Several new demos have been added to showcase different Dioxus capabilities: a counter list (counters.rs), a simple CRM with routing and global signals (crm.rs), a dog breed image fetcher using loaders and actions (dog\_app.rs), a basic hello world (hello\_world.rs), an OpenAI image generator integration (image\_generator\_openai.rs), a README-style counter (repo\_readme.rs), and a full TodoMVC implementation (todomvc.rs). Additionally, a store-based TodoMVC variant (todomvc\_store.rs) demonstrates the new Store macro for nested reactive state, a weather app using fullstack loaders (weather\_app.rs), and a WebSocket chat demo (websocket\_chat.rs) featuring server-side broadcast channels.

examples/01-app-demos · high confidence

The manganis-macro crate now provides the \asset!\ and \option\_asset!\ macros for bundling and referencing static assets, along with a \css\_module\ attribute that generates type-safe, scoped CSS class identifiers from stylesheets. Additionally, a new \\#\[ffi\]\ attribute macro is introduced to generate direct FFI bindings between Rust and native platforms (Swift/Kotlin), enabling native plugin interoperability.

packages/manganis/manganis-macro · high confidence

Added a comprehensive set of new examples in the \03-assets-styling\ directory demonstrating how to manage assets and styling in Dioxus. These include \css\_modules.rs\ for scoped CSS classes, \custom\_assets.rs\ and \dynamic\_assets.rs\ for loading files from the filesystem and intercepting webview requests, and \dynamic\_styles.rs\ for state-driven styling. The examples also cover document metadata and head elements via \document\_title.rs\, \favicon.rs\, \meta.rs\, \script.rs\, and \stylesheet.rs\, as well as font loading strategies in \fonts.rs\ and inline styling in \inline\_styles.rs\. Supporting CSS files for these and other examples (such as calculator, clock, and todomvc) have been added to the \examples/assets\ directory.

examples/assets · high confidence

The interpreter now supports a new \binary-protocol\ feature (requiring \sledgehammer\) that introduces a \MutationState\ struct implementing \WriteMutations\. This allows native platforms (desktop/liveview) to apply DOM mutations via a binary channel rather than the previous JavaScript bridge, improving performance and decoupling the mutation logic from the web-specific interpreter core.

packages/interpreter/src · high confidence

A new \depinfo\ crate has been added to parse rustc's \.d\ dependency files, enabling the hot-reloading engine to perform higher-quality dependency analysis. This allows the development server to more accurately detect which files have changed and trigger rebuilds, resulting in faster and more reliable hot-reload updates for users.

packages/depinfo · high confidence

The CLI now ships dedicated HTML templates for development and production builds. The new dev template includes a styled toast notification system for rebuild status and a loading screen with progress indicators, while the prod template provides a minimal entry point. These changes replace the previous inline or missing templates, ensuring consistent UI feedback during development and a cleaner production bundle.

packages/cli/assets/web · high confidence

A new \dioxus-cli-config\ library has been introduced to centralize and expose the environment variables set by the Dioxus CLI during development. This crate provides a stable API for applications to read configuration values such as server IP, port, devserver address, and app title, rather than relying on raw environment variable names. It includes helper functions like \fullstack\_address\_or\_localhost()\ and \devserver\_ws\_endpoint()\ that automatically handle platform-specific logic (e.g., Android \adb reverse\ adjustments) and support both runtime (debug) and compile-time (release) reading of these values, ensuring correct behavior in both development and standalone production builds.

packages/cli-config/src · high confidence

Added TypeScript and JavaScript implementations for a communication channel between Rust and JavaScript (eval.ts) and a helper function to create elements in the document head (head.ts/head.js). The eval module introduces Channel, WeakDioxusChannel, and DioxusChannel classes to manage asynchronous data exchange, while the head module exposes a window-level function to inject script or link tags into the document head. A hash.txt file and .gitignore were also added to support these new source files.

packages/document/src/js, packages/document/src/ts · high confidence

Added several new demonstration applications to the examples directory. The 'bluetooth-scanner' example showcases a desktop app using background threads to scan for Bluetooth devices and display them in a table. The '05-using-async' directory now includes examples for backgrounded futures, clock updates, general future usage, async streams, and suspense boundaries for handling loading states. Additionally, the '07-fullstack' directory provides examples for a basic fullstack app with client-side counters and server functions, as well as an SSR-only configuration.

(repo-wide) · high confidence

The examples/08-apis directory has been expanded with new demonstrations for desktop and web capabilities. Desktop-specific examples now include custom menus, multiwindow management, tray icons, global shortcuts, overlay windows, and WGPU child windows. Web and cross-platform examples cover file uploads, drag-and-drop, form handling, element focus management, JavaScript evaluation, logging, and element visibility/resize/scrolling. These additions provide practical patterns for integrating native desktop features and advanced web APIs into Dioxus applications.

examples/08-apis · high confidence

Added a new example in \examples/07-fullstack/auth\ that demonstrates integrating \axum-session-auth\ with Dioxus fullstack. The example sets up an in-memory SQLite database to manage users and permissions, configures an Axum router with session and authentication layers, and provides a UI for logging in, logging out, and fetching user details. It showcases how to use the \auth::Session\ extractor in server functions to access the current user and enforce permission-based access control on API endpoints.

examples/07-fullstack/auth · high confidence

The examples/07-fullstack directory has been expanded with new demonstrations for integrating Dioxus with custom Axum routers, handling server-only extractors (such as full request access, headers, and cookies), and managing complex error states with custom HTTP status codes. Additional examples illustrate real-time data patterns using Server-Sent Events (SSE) and Streaming, as well as practical implementations for multipart file uploads and global server state management.

examples/07-fullstack · high confidence

Added new example applications demonstrating Dioxus capabilities: a fullstack desktop app with server functions, a PWA integration, and a Tailwind CSS styled interface. These examples provide reference implementations for building cross-platform applications using these specific integrations.

(repo-wide) · high confidence

The geolocation-native-plugin demo now includes a complete native plugin implementation for both Android and iOS, allowing the application to access precise user location. On Android, the plugin uses Google Play Services to request fine and coarse location permissions and retrieve current or cached positions. On iOS, the plugin leverages CoreLocation for permission handling and location updates, and introduces a new iOS widget extension that displays the current location as a Live Activity on the lock screen, including accuracy indicators and coordinates. The example also provides a modern UI with CSS styling and an animated SVG header to demonstrate these capabilities.

examples/01-app-demos/geolocation-native-plugin · high confidence

The \packages/document/src/elements\ module now provides dedicated components for managing the HTML document head: \Link\ (for stylesheets, preloads, and other link resources), \Meta\ (for metadata tags), \Script\ (for external and inline scripts), \Style\ (for inline styles or linked stylesheets), \Stylesheet\ (a convenience wrapper for stylesheets), and \Title\ (for the page title). These components inject their respective tags into the document head during the initial render, with deduplication logic to prevent duplicate links, scripts, or styles from being added. The \Title\ component is unique in that it supports updates after the initial render, allowing the page title to change dynamically.

packages/document/src/elements · high confidence

The \packages/hooks/src\ module now exposes several new hooks to improve async handling and state management. \use\_action\ allows triggering async work on demand (e.g., form submissions) with automatic cancellation of previous calls. \use\_after\_suspense\_resolved\ lets components run logic once a suspense boundary resolves. \use\_reactive\ and the \Dependency\ trait enable effects and memos to subscribe to non-reactive data as if it were reactive. Additionally, \use\_root\_context\ provides a way to inject default global context, and \use\_set\_compare\ offers an efficient O(1) way to track value equality for collections.

packages/hooks/src · high confidence

The \manganis\ crate has been introduced to centralize asset bundling logic and provide utilities for mobile platform integration. It exposes macros such as \asset\, \css\_module\, \option\_asset\, and \ffi\ for handling static assets and generating native bindings. The crate includes platform-specific modules for Android and Darwin (iOS/macOS), leveraging \jni\ and \objc2\ respectively, along with compile-time serialization helpers to embed metadata into binaries.

packages/manganis/manganis/src · high confidence

The CLI now includes a complete, native Rust-based bundler implementation for iOS, macOS, Linux, and Windows, replacing the previous Tauri v2 bundler. This new system handles the full packaging lifecycle for each platform: iOS IPA creation with code-signing verification, macOS .app bundle assembly with notarization support, Linux packaging (AppImage via linuxdeploy, .deb, and .rpm), and Windows installers (MSI via WiX and NSIS). It also manages the automatic download and caching of external build tools (NSIS, WiX, linuxdeploy, WebView2) and generates updater archives for auto-update distribution.

packages/cli/src/bundler · high confidence

Added a new example in \examples/10-integrations/native-headless\ that demonstrates how to integrate a Dioxus Native app into a wider application by rendering the UI to a texture and driving it with a custom event loop. The example shows how to set up a \DioxusDocument\, configure a WGPU context, use Vello for rendering to a texture, and handle UI events manually.

examples/10-integrations/native-headless, examples/10-integrations/wgpu-texture · high confidence

The \packages/fullstack/src/payloads\ module has been expanded with new types to support additional data formats and communication patterns. Users can now serialize and deserialize request/response bodies using CBOR, MessagePack, and Postcard formats via the \Cbor\, \MsgPack\, and \Postcard\ extractors. Streaming capabilities are enhanced with \Streaming\ (including \TextStream\, \ByteStream\, and \JsonStream\) for chunked data transfer, \ServerEvents\ for Server-Sent Events (SSE) with automatic JSON deserialization, and \FileStream\ for streaming file uploads and downloads. Additionally, \MultipartFormData\ handles multipart form submissions, \Query\ supports complex query parameter deserialization, \SetHeader\ allows setting response headers, and \UseWebsocket\ provides a reactive hook for full-duplex WebSocket connections.

packages/fullstack/src/payloads · high confidence

The examples/09-reference directory now includes a comprehensive set of reference guides demonstrating key Dioxus capabilities. The new all\_events.rs example provides a practical way to inspect event data for mouse, keyboard, selection, beforeinput, and paste events. Additional examples cover defining typed custom elements (custom\_element.rs), creating generic components (generic\_component.rs), using the HTML builder API (html\_builder.rs), managing optional props (optional\_props.rs), leveraging RSX macro features (rsx\_usage.rs), using shorthand syntax (shorthand.rs), rendering lists (simple\_list.rs), spreading attributes (spread.rs), integrating web components (web\_component.rs), and verifying XSS safety (xss\_safety.rs).

examples/09-reference · high confidence

The router package now exposes a set of new components to handle navigation, layout, and history. Users can now use \Link\ for client-side navigation with support for active classes, external links, and custom event handlers; \Outlet\ to render nested route content within layouts; \ChildRouter\ to support nested router hierarchies with automatic route mapping; \HistoryProvider\ to inject history context; and \GoBackButton\/\GoForwardButton\ for programmatic history navigation. Additionally, \FailureExternalNavigation\ provides a default UI for failed external link clicks. These components replace or supplement the previous macro-based router usage by providing explicit, composable building blocks for routing logic.

packages/router/src/components · high confidence

Added a suite of new examples in the routing section (06-routing) demonstrating the enum-based router, including flat routing with layouts, hash-fragment state persistence, query-segment search, nested routes with redirects, reactive resources, and scroll restoration. Also added a fullstack example (07-fullstack/router) that integrates the router with server functions, showcasing client-server data exchange and incremental server-side rendering configuration.

examples/06-routing, examples/07-fullstack/router · high confidence

Added eight new example files in the signals package to demonstrate various signal patterns, including context providers, memoization, mapped signals, read-only degradation, cross-thread synchronization, and split subscriptions.

packages/signals/examples · high confidence

The \packages/stores/src/impls\ module now provides dedicated store implementations for common Rust collections, including \Vec\, \HashMap\, \BTreeMap\, \Option\, \Result\, and slices. These implementations add reactive methods such as \len\, \is\_empty\, \iter\, \insert\, \remove\, and \clear\ that correctly track shallow changes (like additions or removals) versus deep changes (like value modifications), ensuring that UI components re-render only when necessary. Additionally, new indexing capabilities allow accessing specific items in a \Vec\ or entries in a map as individual stores, and utility methods like \deref\, \transpose\, and \unwrap\ are available for \Option\ and \Result\ stores to simplify working with nested types.

packages/stores/src/impls · high confidence

The event handling system in \packages/html/src/events\ has been completely rewritten to use a trait-based architecture, introducing dedicated data structures and types for a wide range of HTML events including animation, beforeinput, cancel, clipboard, composition, drag, focus, form, image, keyboard, media, and more. This change provides users with strongly-typed event data (e.g., \AnimationData\, \BeforeInputData\, \FormData\) that exposes specific properties like animation names, input types, form values, and clipboard data, replacing the previous generic or less structured approach. The new system also includes serialization support for cross-platform event transport and a centralized event converter mechanism.

packages/html/src/events · high confidence

The CLI now uses a comprehensive, structured configuration system in \packages/cli/src/config\ to manage application settings, bundling, and platform-specific manifests. Users can now configure unified permissions (e.g., camera, location) that are automatically mapped to Android \AndroidManifest.xml\ and iOS/macOS \Info.plist\ entries via the new \ManifestMapper\. The schema supports deep linking, background modes, and platform overrides for iOS, Android, macOS, Windows, and Linux. Additionally, it introduces inline config extraction from Rust doc comments for examples, customizable \public\_dir\ defaults, and detailed bundling settings for Debian, Wix, and native platforms.

packages/cli/src/config · high confidence

The \packages/web/src\ directory has been completely rewritten to introduce a new web renderer architecture. This update adds a configurable launch system (\Config\) allowing users to specify root elements and enable SSR hydration. It introduces a new \Document\ trait and \WebDocument\ provider to manage head elements (scripts, styles, links) and integrates with \dioxus\_history\ for browser history management. The renderer now supports drag-and-drop via \WebDataTransfer\, file uploads via \WebFileData\, and robust hot-reloading through a WebSocket-based devtools connection that handles live patches and rebuild toasts. Hydration logic has been implemented to bind pre-rendered HTML, including support for suspense boundaries and mounted events.

packages/web/src · high confidence

This change introduces several foundational updates to the repository structure and documentation. A new \.gitattributes\ file enforces consistent LF line endings across text files and marks binary assets (images, WASM) as binary, ensuring cross-platform consistency. The \README.md\ has been significantly expanded to highlight version 0.7 features, including cross-platform support, hot-reloading, and fullstack capabilities, accompanied by new badges and images. Additionally, an \AGENTS.md\ guide is added to document the workspace architecture and key concepts for AI agents, while \flake.nix\ and \flake.lock\ provide a standardized Nix development shell environment. The \.gitignore\ is updated to exclude Playwright test artifacts and IDE-specific files, and \lychee.toml\ configures link checking to exclude protected domains.

(repo-wide) · high confidence

The devtools package now supports sub-second hot-reloading via binary patching. This introduces new types for hot-reload messages (templates, assets, jump tables) and functions to apply these patches to the VirtualDom and runtime signals. It also adds a \serve\_subsecond\ API that allows developers to run an asynchronous server (such as an Axum router) which automatically restarts or patches itself upon code changes, enabling faster development feedback loops without full rebuilds.

packages/devtools · high confidence

The \Routable\ derive macro now parses and generates code for query strings and URL hash fragments. Routes can include query parameters using the \?\ syntax (e.g., \/:dynamic?:query\ or \/:dynamic?:arg1&:arg2\), and hash fragments using the \\#\ syntax (e.g., \/:dynamic\#:\<field\>\). The macro automatically handles encoding/decoding these segments and ensures they are preserved when generating links or matching routes.

packages/router-macro · high confidence

The \html-validation\ crate, which provided compile-time validation for HTML elements and attributes, and the \virtual-dom-rs\ package, a standalone Virtual DOM implementation for Rust/WASM, have been completely removed from the codebase. This deletion eliminates the ability to use these specific HTML validation helpers and the legacy virtual-dom rendering engine.

packages/html-validation, packages/virtual-dom-rs · high confidence

The \virtual-node\ package has been removed from the codebase. This change eliminates the standalone \VirtualNode\ enum, along with its associated \VElement\ and \VText\ structs and their implementation methods (such as DOM creation and text spacing utilities). Additionally, the \virtual\_node\_test\_utils\ module, which provided helper functions for filtering virtual nodes by label, is no longer available. This aligns with the effort to dissolve the virtual node crate into \dioxus-core\.

packages/html-macro, packages/html-macro-test, packages/virtual-node · high confidence

The internal macro implementation in \packages/html-internal-macro/src\ has been reorganized from a single file into distinct modules (\common\, \elements\, \events\, \extension\_attributes\). This change extracts shared parsing logic and type definitions into \common.rs\, separates the \define\_elements!\ macro logic into \elements.rs\, moves event handler generation to \events.rs\, and isolates attribute extension trait generation into \extension\_attributes.rs\. For users, this is an internal structural change that maintains the existing public API and macro behavior while improving code maintainability.

packages/html-internal-macro/src · high confidence

The autofmt package has been refactored to use a new internal architecture for formatting RSX code. This change introduces dedicated modules for managing the output buffer (\buffer.rs\), handling indentation options (\indent.rs\), and collecting macros from source files (\collect\_macros.rs\). The core formatting logic has been reorganized into a \Writer\ struct that processes RSX bodies, while expression unparsing is now handled via a \prettier\_please\ module that integrates with the \prettyplease\ library. These internal structural changes support improved handling of indentation, comments, and nested RSX blocks, though the public API surface (such as \try\_fmt\_file\ and \fmt\_block\) remains largely consistent for consumers.

packages/autofmt/src · high confidence

The desktop application now includes a development-only toast notification system to inform users when a non-hot-reloadable change triggers a rebuild. This is implemented via a new \dev.index.html\ asset that injects the toast UI, CSS, and JavaScript logic (including accessibility attributes like \aria-hidden\ and session-storage-based persistence across reloads), while a new \prod.index.html\ provides a minimal, clean template for production builds without these development aids.

packages/desktop/src/assets · high confidence

The CLI has been completely rewritten, introducing a new \dx\ command structure with subcommands like \serve\, \build\, \bundle\, \check\, and \init\. JavaScript bundling now uses esbuild (v0.27.3) instead of the previous SWC library, with binaries downloaded and cached locally. The CLI now supports a \--platform\ flag to target web, desktop (macos, windows, linux), mobile (ios, android), server, and liveview builds. Logging has been migrated to the \tracing\ ecosystem with a custom \TraceController\ that routes user-facing logs to the TUI and internal logs to files, while also collecting anonymized telemetry via PostHog. Configuration is now managed through a global TOML settings file (\CliSettings\) supporting options like \always\_on\_top\, \no\_downloads\, and \disable\_telemetry\. The CLI also includes a rustc wrapper (\rustcwrapper.rs\) to intercept build commands for fast hot-patching, and integrates Tailwind CSS v3/v4 autodetection and installation.

packages/cli/src · high confidence

The \dx serve\ command has been completely rewritten to provide a richer development experience. The new implementation introduces a terminal user interface (TUI) for interactive status updates, replacing the previous plain-text output. It now supports Rust hot-patching by default, allowing for sub-second rebuilds without full restarts, and includes a robust HTTP/WebSocket proxy layer to handle backend connections and WebSocket upgrades. The serve engine also features improved file watching, better error handling for build failures, and configurable hot-reload modes (hot-patch, RSX-only, or disabled).

packages/cli/src/serve · high confidence

The build logic in \packages/cli/src/build\ has been completely rewritten to support a new end-to-end build process for all major platforms (Mac, Windows, Linux, iOS, Android, and WebAssembly). This change introduces dedicated modules for each platform (\android.rs\, \apple.rs\, \windows.rs\, \web.rs\) and a new asset system (\assets.rs\) that performs hashing at build time by parsing binary symbols. It also includes a new hot-patching engine (\patch.rs\, \link.rs\) that intercepts the linker to enable binary patching and sub-second rebuilds, replacing the previous interception method. The \builder.rs\ module now manages a single-app build lifecycle with detailed progress tracking, while \context.rs\ handles build state and progress updates.

packages/cli/src/build · high confidence

The \packages/html/src\ module has been completely rewritten to provide a modern, type-safe HTML abstraction. This change introduces a new \define\_elements!\ macro and \attribute\_groups.rs\ to generate compile-time correct HTML elements and attributes, replacing the previous ad-hoc definitions. It also introduces structured data types for user interactions, including \geometry.rs\ for coordinate spaces (screen, client, element, page), \input\_data.rs\ for mouse and keyboard states, and \data\_transfer.rs\ for drag-and-drop operations. Additionally, a new \transit.rs\ module defines a serializable \HtmlEvent\ and \EventData\ enum, enabling robust event handling and serialization for features like LiveView and hot-reloading.

packages/html/src · high confidence

The event handling layer in \packages/web/src/events\ has been completely rewritten to implement the \HtmlEventConverter\ trait and provide synthetic event wrappers for a comprehensive set of web events. This change introduces support for new event types including \beforeinput\, \visible\ (via IntersectionObserver), \mounted\ (with scroll and focus capabilities), \resize\ (via ResizeObserver), \selection\, \toggle\, \animation\, \transition\, \composition\, \cancel\, and \media\. It also significantly enhances existing events: drag events now correctly use \DragEvent\ with full \DataTransfer\ and file support; clipboard events expose file data; form events now extract full form values including select options and file inputs; and scroll events provide detailed geometry data (scroll top/left/width/height, client width/height) for both elements and the document. The implementation replaces the previous event system with a modular structure where each event type has its own module implementing specific data traits (e.g., \HasScrollData\, \HasDragData\) and the \WebEventExt\ trait for downcasting.

packages/web/src/events · high confidence

The const-serialize module has been rewritten to serialize data using the CBOR (Concise Binary Object Representation) format instead of the previous implementation. This change introduces new source files (cbor.rs, array.rs, enum.rs, list.rs, primitive.rs, str.rs, struct.rs) that handle the binary encoding of primitives, strings, arrays, lists, structs, and enums into CBOR byte sequences, enabling more compact and standardized constant serialization for downstream consumers.

packages/const-serialize/src · high confidence

The core library has been significantly refactored to support a new component model and runtime architecture. This includes the introduction of type-erased props via the \AnyProps\ trait and \VProps\ struct, enabling more flexible component memoization and rendering. A new arena system (\arena.rs\) manages renderer-local element and mount IDs, allowing multiple render targets to share a single logical VirtualDom. The event system (\events.rs\) has been rewritten to support bubbling, propagation control, and default action prevention. Additionally, new modules for error boundaries (\error\_boundary.rs\), effects (\effect.rs\), and fragments (\fragment.rs\) provide robust error handling, post-render side effects, and keyable inline grouping. The runtime context (\global\_context.rs\) now exposes functions for spawning tasks, managing context, and handling suspense, while \generational\_box.rs\ integrates with the generational-box crate for copy-state management.

packages/core/src · high confidence

The desktop renderer has been completely rewritten to improve stability and maintainability. The core event loop and window management are now handled by a new \App\ struct, while window-specific state is managed via \DesktopWindowContext\ and exposed through a new \DesktopContext\ API. A new \AssetHandlerRegistry\ allows for custom asset handling, and a dedicated \android\_sync\_lock\ module resolves thread-safety issues on Android. Additionally, the edit queue now uses a WebSocket connection for more efficient communication between the VirtualDom and the webview, and a new \document.rs\ module provides a structured way to manage head elements like scripts and styles.

packages/desktop/src · high confidence

The \dioxus-logger\ crate has been merged into the main \dioxus\ package, meaning users of Dioxus v0.6 no longer need to install a separate dependency. The library now exposes a \dioxus::logger\ module that initializes a \tracing\-based logging facade automatically during \dioxus::launch\. Users can still override the default log level (INFO for release, DEBUG for debug builds) or configure environment-based filtering via \RUST\_LOG\ by calling \dioxus::logger::init\ before launch. For non-WASM targets, the logger respects the \RUST\_LOG\ environment variable and suppresses noisy debug logs from \hyper\_util\ by default.

packages/logger · high confidence

The document package now includes a build script (build.rs) that manages TypeScript-to-JavaScript bundling and file watching, along with a TypeScript configuration (tsconfig.json) defining compilation options. Additionally, placeholder JavaScript and CSS asset files have been added to the assets directory, intended for inclusion in tests.

packages/document, packages/document/assets · medium confidence

The manganis package now includes empty script.js and style.css files in its assets directory. These files currently contain no code or styles, serving as placeholders for future optimization or styling logic.

packages/manganis/manganis/assets · medium confidence

The generational box implementation has been restructured into modular source files (entry, error, references, sync, unsync) to support more robust memory management. The new error types (BorrowError, BorrowMutError, ValueDroppedError) provide detailed diagnostic information, including source locations for borrows and drops when debug features are enabled. The storage backends (SyncStorage and UnsyncStorage) now use reference-counted entries and generational tracking to prevent use-after-free errors, with improved borrow guards that track creation and drop locations for better debugging.

packages/generational-box/src · high confidence

The history provider is now managed via Dioxus context providers (\provide\_context\/\provide\_root\_context\) instead of being a standalone service. If no platform-specific history provider is found in the context, the system automatically falls back to an in-memory history provider (\MemoryHistory\), ensuring navigation continues to work even when the renderer does not explicitly support history. The \MemoryHistory\ implementation also now supports a configurable base path prefix via \with\_prefix\, which is used to adjust route paths for rendering and navigation in environments where the application is not rooted at \/\.

packages/history · high confidence

The \dioxus-interpreter-js\ package has shifted its implementation from raw JavaScript to TypeScript, introducing a new build process that compiles TypeScript sources (located in \src/ts\) into JavaScript via Bun. This change includes a new \build.rs\ script to manage the compilation of specific modules like \set\_attribute\, \native\, \core\, \hydrate\, and \streaming\, along with a \tsconfig.json\ for type checking and a \.gitignore\ to exclude the generated \gen2/\ output. Users contributing to the interpreter bindings now need to have the TypeScript compiler and Bun installed.

packages/interpreter · high confidence

The SSR module has been overhauled to use a template-based rendering strategy that caches static HTML segments for faster performance. This change introduces robust XSS protection by correctly escaping text content based on its context (e.g., inside script/style tags vs. normal elements) and fixes several rendering bugs, including proper handling of boolean attributes, style attributes, and dynamic inner HTML.

packages/ssr/src · high confidence

The asset handling core has been restructured to use a typed \AssetOptions\ system, replacing the previous generic approach with specific builders for images, CSS, CSS modules, JavaScript, and folders. This introduces granular control over asset processing, including image format conversion (PNG, JPG, WebP, AVIF), CSS minification, preloading, and static head insertion for JS/CSS. A new CSS Modules feature is added, providing automatic class hashing and a parser to transform selectors while preserving \:global()\ scopes. Additionally, JavaScript assets can now be marked as ES modules, and platform-specific metadata for Android and iOS is supported via a unified FFI symbol system.

packages/manganis/manganis-core · high confidence

The Android platform integration has been rewritten to provide a robust foundation for mobile APIs. This includes a new \with\_activity\ helper for executing JNI operations, a generic callback system for loading DEX classes and registering native methods, and utility functions for common JNI tasks like permission checks. Crucially, the native callback implementation now correctly handles pointer reconstruction for 32-bit Android targets (e.g., armv7), ensuring compatibility across all supported architectures.

packages/manganis/manganis/src/android · high confidence

The CLI now generates a complete Android project structure in the \gen\ directory, replacing previous placeholder assets. This new template uses Gradle 9.1.0 and configures the app to compile with Java 17. It includes a customizable \build.gradle.kts\ that supports release signing via \android\_bundle\ configuration, ProGuard minification, and dynamic dependency injection from the project manifest. The generated \AndroidManifest.xml\ now allows users to specify permissions, hardware features, URL schemes, app links, and a foreground service type directly in their configuration, while the \MainActivity\ extends \WryActivity\ to handle the web view integration.

packages/cli/assets/android/gen · high confidence

The JavaScript runtime layer in \packages/interpreter/src/js\ has been replaced with a new set of modules (\core.js\, \native.js\, \common.js\, etc.) that handle DOM interpretation, event serialization, and hydration. This change introduces support for new browser events including \resize\, \visible\ (via IntersectionObserver), \beforeinput\, \auxclick\, and \scrollend\, while also adding specific handling for file drag-and-drop, form submission, and selection events. The new interpreter manages element attributes, styles, and event listeners through a stack-based virtual DOM diffing approach, replacing the previous implementation to improve performance and feature parity with modern web standards.

packages/interpreter/src/js · high confidence

The interpreter layer has been rewritten in TypeScript, introducing a new \BaseInterpreter\ and \NativeInterpreter\ that handle DOM-to-VirtualDOM mapping, event serialization, and attribute management. This change adds support for streaming hydration via \register\_rehydrate\_chunk\_for\_streaming\ and \dx\_hydrate\, allowing chunks to be queued and processed as they arrive. It also introduces new event handlers for \resize\ and \visible\ (using ResizeObserver and IntersectionObserver), and improves desktop file handling by preventing default navigation on drops and properly triggering native file dialogs for \\<input type="file"\>\. The new codebase includes dedicated modules for event serialization (\serialize.ts\), attribute setting (\set\_attribute.ts\), and console logging over WebSocket (\patch\_console.ts\), replacing the previous JavaScript-based interpreter logic.

packages/interpreter/src/ts · high confidence

A new \core-types\ crate has been introduced to host foundational types and utilities, specifically extracting the \event\_bubbles\ logic (which defines bubbling behavior for events like \cancel\, \auxclick\, \scrollend\, and \toggle\) and the \is\_bundled\_app\ detection function. This separation allows the interpreter to determine event propagation and build context without depending on heavier libraries like \dioxus-html\, thereby reducing the dependency graph and improving compile times.

packages/core-types · high confidence

The hydration logic in the web package has been replaced with a new markerless approach that walks the Virtual DOM to match server-rendered nodes, eliminating the need for hydration markers in the DOM. This change introduces a \HydrationCursor\ to handle DOM traversal, text splitting, and wrapper skipping, and adds specific support for streaming Suspense boundaries, allowing the client to rehydrate resolved suspense content and handle server-side errors bubbling up to error boundaries.

packages/web/src/hydration · high confidence

The \rsx-hotreload\ package has been split into a dedicated crate with a new internal architecture for detecting and applying hot-reload changes. This change introduces a new diffing engine that uses a greedy algorithm to match old and new RSX templates by scoring dynamic context pools (text segments, nodes, and attributes), allowing for more granular updates without full rebuilds. The new implementation includes a file-level comparison module (\collect.rs\) that isolates RSX macro changes from general Rust code changes, and a state management system (\last\_build\_state.rs\) to track dynamic item usage across builds. This refactoring improves the precision of hot-reload patches and reduces the likelihood of unnecessary full rebuilds when only specific template parts change.

packages/rsx-hotreload/src · high confidence

The router package introduces dedicated hooks for accessing navigation state and history: \use\_navigator\ allows components to programmatically change the route history, while \use\_route\ provides the current routing location. Additionally, \use\_router\ is now deprecated in favor of the non-hook \router()\ and \try\_router()\ functions, which access the router context without subscribing to updates, offering a more explicit API for consumers who do not need reactive route changes.

packages/router/src/hooks · high confidence

This change introduces a new typed view builder system in \packages/core/src/view/\ (including \ElementBuilder\, \FragmentBuilder\, and attribute/child builders) that replaces the previous view representation, and adds a new \packages/core-template\ crate providing optimized, const-evaluated template storage with compact path encoding and anchor-based dynamic slot resolution. For users, this means the underlying view construction and template lowering mechanism has changed, which may affect custom view implementations or direct usage of internal view types, while generally aiming to improve compile-time performance and template efficiency.

(repo-wide) · high confidence

The \rsx!\ macro parser has been restructured to use dedicated, strongly-typed structs for parsing elements, components, and control flow (for loops, if chains), replacing the previous monolithic approach. This change introduces a \Diagnostics\ collection that allows the macro to emit detailed, span-specific compiler errors and warnings for invalid syntax (such as lowercase component names or duplicate props) rather than failing silently or panicking. Additionally, a new \FillOrderVisitor\ trait centralizes the traversal logic for template bodies, ensuring that static and dynamic attributes are processed in the correct order for hot-reloading and rendering, while \HotLiteral\ types now support granular hot-reload updates for formatted strings.

packages/rsx/src · high confidence

The diffing logic in \packages/core/src/diff\ has been restructured into a modular system (attributes, component, context, iterator, node, placement, template) to fix multiple reconciliation bugs and improve stability. Key changes include a new attribute diffing algorithm that correctly handles spread attributes and volatile values using a 'last write wins' reduction, a robust fragment child reconciliation strategy that skips stable edge scans when unnecessary, and refined component scope diffing that properly handles suspended states and mount identity reuse. These updates ensure that dynamic attributes, keyed and non-keyed lists, and component lifecycles are reconciled accurately, preventing issues like lost event handlers, incorrect DOM placement, and hydration mismatches.

packages/core/src/diff · high confidence

The router's internal context management has been refactored into three distinct modules: \navigator.rs\, \outlet.rs\, and \router.rs\. Users now have a dedicated \Navigator\ struct (accessible via the \navigator()\ function) that provides explicit methods for history navigation (\go\_back\, \go\_forward\, \push\, \replace\) and state checking (\can\_go\_back\, \can\_go\_forward\), separating navigation actions from the broader router state. Additionally, a new \OutletContext\ system has been introduced to manage nested routing levels, exposing a \use\_outlet\_context\ hook that allows components to query their current nesting depth, which supports more robust handling of hierarchical route structures and error rendering within nested outlets.

packages/router/src/contexts · high confidence

The signals implementation has been reorganized into distinct modules, introducing a new CopyValue wrapper that manages generational storage and scope ownership, and adding MappedSignal and MappedMutSignal types that allow deriving read-only or read-write views into existing signals without cloning. The core Signal type now wraps this CopyValue internally, and the crate exposes Readable and Writable traits to unify access across signal variants, while also adding a SetCompare utility for efficient value comparison and a warning system to detect CopyValue hoisting across scopes.

packages/signals/src · high confidence

The \dioxus\ crate now exposes a centralized \launch()\ function and a \LaunchBuilder\ that determine the rendering platform based on enabled Cargo features (such as \web\, \desktop\, \mobile\, \server\, \liveview\, and \native\). This change consolidates application startup logic, allowing users to select their target platform via feature flags rather than importing platform-specific launchers directly, and provides a builder API for configuring contexts and custom launch behaviors.

packages/dioxus/src · high confidence

This change introduces a dedicated channel mechanism for handling JavaScript evaluation within the Dioxus desktop environment. By implementing \NativeDioxusChannel\ in both JavaScript and TypeScript, the app now properly manages message queues and garbage collection via a finalization registry, ensuring that resources are correctly cleaned up when evaluation contexts are dropped. This resolves issues with the previous \eval\ implementation, providing a more stable bridge between Rust and the browser's JavaScript engine.

packages/desktop/src/js, packages/desktop/src/ts · high confidence

Add Playwright tests for CLI asset optimization and module handling; Added CLI test harnesses for platform and feature resolution; Added JS Framework and Keyed Diff benchmarks; Added SSR test coverage for rendering edge cases; Added benchmark suite for generational box storage operations; Added compile-time and runtime tests for macro-generated components; Added compile-time tests for fullstack server functions; Added comprehensive test suite for generational-box; Added comprehensive test suite for the autofmt formatter; Added comprehensive tests for RSX hot-reload edge cases; Added end-to-end and serialization tests for the interpreter; Added headless integration tests for desktop event handling and rendering; Added parsing tests for RSX CallBody validation; Added regression tests for autofmt edge cases; Added server-side rendering tests for the router; Added test coverage for Dioxus Stores visibility, macro generation, and reactive updates; Added test coverage for HTML-to-RSX translation edge cases; Added test coverage for const-serialize serialization and deserialization; Added test for missing trailing comma error span; Added tests for autofmt handling of asset expressions and basic JSX structures; Added tests for effect reruns and memo stability; Added tests for router parent/child relationships, URL parsing, and static route mapping; Added unit tests for signal creation, memoization, and subscription behavior; Comprehensive test suite for Dioxus core diffing and lifecycle behavior; Expanded test coverage for the autofmt RSX formatter; Updated test suite structure for html-internal-macro.

The repository now includes a generated \Cargo.lock\ file to pin all transitive dependencies, ensuring reproducible builds. Additionally, a collection of new example projects has been added under \examples/\, including \bluetooth-scanner\, \ecommerce-site\, \file-explorer\, \geolocation-native-plugin\, \hackernews\, \hotdog\, and several fullstack demonstrations (\auth\, \desktop\, \hello-world\, \router\, \ssr-only\). These examples provide starting templates for various Dioxus capabilities such as fullstack rendering, desktop/mobile support, and native plugin integration.

(dependencies) · high confidence

New internal documentation and release guides added to notes/; Removal of empty test module in packages/redux.

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

• CAI 49 → 66 (+16.8)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 66 → 66 (+0.6)
• Architecture 97 → 98 (+0.9)
• Maturity 69 → 76 (+7.0)
• Readiness 32 → 93 (+61.0)
• Security 58 → 69 (+11.6)
• Accessibility 59 (new)

• Change coupling: common.js ↔ core.js (packages/interpreter/src/js/common.js)
• Change coupling: common.js ↔ native.js (packages/interpreter/src/js/common.js)
• Change coupling: common.js ↔ native.ts (packages/interpreter/src/js/common.js)
• Change coupling: core.js ↔ native.js (packages/interpreter/src/js/core.js)
• Change coupling: native.js ↔ serialize.ts (packages/interpreter/src/js/native.js)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• High CVE: [GHSA redacted] (packages/extension/package-lock.json)
• …and 96 more

• App::handle_hot_reload_msg (cognitive 18) (packages/desktop/src/app.rs)
• App::persist_window_state (cognitive 19) (packages/desktop/src/app.rs)
• AppBuilder::finish_build (cyclomatic 18) (packages/cli/src/build/builder.rs)
• AppBuilder::get_android_device_transport_id (cognitive 24) (packages/cli/src/build/builder.rs)
• AppBuilder::get_ios_device_uuid (cognitive 18) (packages/cli/src/build/builder.rs)
• AppBuilder::wait (cognitive 23) (packages/cli/src/build/builder.rs)
• AppBuilder::wait (cyclomatic 39) (packages/cli/src/build/builder.rs)
• AppServer::handle_file_change (cognitive 114) (packages/cli/src/serve/runner.rs)
• AppServer::handle_file_change (cyclomatic 46) (packages/cli/src/serve/runner.rs)
• AppServer::wait (cognitive 20) (packages/cli/src/serve/runner.rs)
• AppServer::watch_filesystem (cognitive 19) (packages/cli/src/serve/runner.rs)
• AppServer::workspace_dep_chain (cognitive 26) (packages/cli/src/serve/runner.rs)
• BlitzBackend::set_attribute_impl (cognitive 20) (packages/native-dom/src/mutation_writer.rs)
• BlitzBackend::set_attribute_impl (cyclomatic 20) (packages/native-dom/src/mutation_writer.rs)
• BuildRequest::android_env_vars (cyclomatic 16) (packages/cli/src/build/android.rs)
• BuildRequest::auto_provision_entitlements (cognitive 27) (packages/cli/src/build/apple.rs)
• BuildRequest::auto_provision_entitlements (cyclomatic 20) (packages/cli/src/build/apple.rs)
• BuildRequest::cargo_build (cognitive 27) (packages/cli/src/build/request.rs)
• BuildRequest::cargo_build (cyclomatic 18) (packages/cli/src/build/request.rs)
• BuildRequest::cargo_build_arguments (cognitive 20) (packages/cli/src/build/request.rs)
• …and 763 more

• 14 commits — 8 feature/other, 6 fixes

• packages/cli — 4 commits
• packages/native-dom — 3 commits
• (root) — 2 commits
• packages/core — 1 commit
• packages/hooks — 1 commit
• packages/liveview — 1 commit
• packages/manganis — 1 commit
• packages/rsx — 1 commit

• fix: Fix manganis-macro resolve_missing_file_path test on Windows (#5762)
• fix: Fix windows-hotpatch-fullstack flake: route LaunchedRoot through Subsecond; remove SymbolData probe log spam (#5790)
• fix: cli: mirror Cargo's implicit strip default when manually stripping binaries (fixes wasm-opt SIGABRT) (#5736)
• fix: fix(bundle): honor runtime no-downloads setting (#5748)
• fix: fix(liveview): don't double the ? and # when reading the browser location (#5836)
• fix: fix(rsx): quote_spanned! -> quote!. Resolves clippy::useless_format lints. (#5636)
• change: Introduce a function to create a synthetic form event (#5750)
• change: Markerless placeholders/Portals/Multiwindow/const builder/optimized templates (#5554)
• change: Set X-Forwarded-Host in the proxy (#5627)
• change: Skip stable fragment edge scans when no children need placement (#5802)
• change: Upgrade to Blitz 0.3.0-beta.2 (#5780)
• change: Use the empty namespace by default on HTML attributes (#5851)
• change: feat(desktop): make libxdo opt-in on Linux via linux-libxdo (#5749)
• change: lychee: exclude freyaui.dev (Vercel bot protection returns 403 to lychee) (#5844)

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

DioxusLabs/dioxus 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.