Skip to content
CAI
Software that uses CAICheck a score

DioxusLabs/dioxus

58.5

Adequate · 14 November 2026

153.4k

lines of production code

Rust

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Hacker News demo application

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

Add e-commerce site example using FakeStoreAPI and Tailwind CSS

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

Add file-explorer desktop app example

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

Add internal router subscription hook

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

Added build automation and documentation for Dioxus-web

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

Axum adapter for hosting LiveView apps

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

Initial release of dioxus-desktop package with build and documentation scaffolding

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

Initial release of the Dioxus VS Code extension

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

Initial release of the Dioxus VS Code extension with RSX formatting and HTML-to-RSX translation

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

Introduce Dioxus LiveView for server-rendered web apps

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

Introduce Dioxus Native as a new native rendering backend

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

Introduce Dioxus Router package with navigation hooks and components

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

Introduce HTML-to-RSX conversion utility

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

Introduce WASM module splitting for lazy loading

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

Introduce WebDioxusChannel for JavaScript-Rust communication

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

Introduce component manifest schema and CLI helper logic

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

Introduce const\_serialize macro for compile-time serialization

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

Introduce cross-platform asset resolver for native and web bundles

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

Introduce dioxus-fullstack package with client, encoding, and lazy initialization modules

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

Introduce dioxus-fullstack-core as a lightweight integration layer

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

Introduce document package for platform-agnostic document and JavaScript evaluation

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

Introduce global signals and memos for application-wide state

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

Introduce headless native DOM renderer integration with Blitz

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

Introduce incremental static rendering and server-side document management

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

Introduce platform-specific configuration macros

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

Introduce reactive Store system for nested data structures

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

Introduce structured CLI output format for machine consumption

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

Introduction of CLI telemetry and crash analytics

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

Introduction of Subsecond, a Rust hot-reloading library

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

Introduction of dedicated HTTP method route macros

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

Lazy TypeScript binding generation with incremental hashing

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

New Axum integration examples for LiveView

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

New Dioxus examples for Bluetooth scanning, async patterns, and fullstack apps

Added several new example applications to the repository: a Bluetooth scanner desktop app demonstrating background threads and device scanning; a suite of async examples covering backgrounded futures, clocks, streams, and suspense boundaries for loading states; and fullstack examples showing client-server interaction with server functions and server-side rendering-only setups.

examples/01-app-demos/bluetooth-scanner, examples/07-fullstack/hello-world, examples/07-fullstack/ssr-only · high confidence

New Dioxus examples for Bluetooth scanning, async patterns, and fullstack apps

Added several new example applications to the repository: a Bluetooth scanner desktop app demonstrating background threads and device scanning; a suite of async examples covering backgrounded futures, clocks, streams, and suspense boundaries for loading states; and fullstack examples showing client-server interaction with server functions and server-side rendering-only setups.

examples/05-using-async · high confidence

New Dioxus examples for UI building and state management

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/04-managing-state · high confidence

New HTML-to-RSX conversion example

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

New HotDog demo app with favorites and server-side persistence

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

New PWA and Tailwind CSS integration examples

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

New \`Store\` derive macro and \`\#\[store\]\` attribute for reactive state management

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

New and updated application demos in examples/01-app-demos

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

New asset and CSS module macros with FFI bridge support

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

New asset and styling examples for Dioxus

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

New binary-protocol mutation channel for native platforms

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

New dep-info parser for improved hot-reloading accuracy

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

New dioxus-cli-config crate for accessing CLI environment variables

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

New document evaluation and head manipulation utilities

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

New examples for desktop and web APIs in examples/08-apis

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

New fullstack and integration examples added

Added new example projects demonstrating Dioxus capabilities: a fullstack desktop app with server functions (examples/07-fullstack/desktop), a PWA integration (examples/10-integrations/pwa), and a Tailwind CSS integration (examples/10-integrations/tailwind). Also added a script to scrape and document these examples.

(repo-wide) · high confidence

New fullstack authentication example with session-based login and permissions

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

New fullstack examples showcase advanced server capabilities

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

New geolocation native plugin example with iOS Live Activity and Android location services

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

New head-element components for document metadata and resources

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

New hooks for async actions, suspense, and reactive collections

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

New integrated logging package with WASM support

A new \dioxus-logger\ package has been introduced to centralize logging configuration. It provides \initialize\_default\ and \init\ functions to set up the global tracing subscriber, automatically selecting DEBUG or INFO levels based on build mode. On WebAssembly targets, it replaces the external \tracing-wasm\ crate with a custom \WasmLayer\ implementation that routes logs to browser console methods and records performance timings, while non-WASM targets use a standard formatter with environment-based filtering.

packages/logger/src · high confidence

New manganis crate for asset bundling and mobile FFI utilities

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

New native-headless integration example

Added a new example demonstrating 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. This example shows how to set up a WGPU context, create a Vello renderer, paint the Dioxus document into a scene, and handle UI events manually, providing a sketch for headless or embedded rendering scenarios.

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

New payload types for serialization, streaming, and real-time communication

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

New reference examples for event handling, custom elements, and component patterns

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

New router component primitives for navigation and layout

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

New routing and fullstack server-function examples

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

New signal usage examples added to documentation

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

New store implementations for Vec, HashMap, BTreeMap, and more

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

New trait-based event system with comprehensive event types

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

New web renderer implementation with hydration and devtools support

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

Repository configuration and documentation overhaul

This update introduces several foundational changes to the repository structure and documentation. A new \AGENTS.md\ file provides a comprehensive architecture guide and workspace structure for developers and AI agents. The \README.md\ has been significantly expanded to highlight version 0.7 features, including cross-platform support, hot-reloading, and fullstack capabilities, with updated examples and badges. Additionally, the repository now includes \.gitattributes\ to enforce consistent line endings, a \flake.nix\ for Nix-based development environments, and updated \.gitignore\ rules to better handle build artifacts and IDE files.

(repo-wide) · high confidence

Sub-second hot-reloading and binary patching support

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

Support for query strings and hash fragments in route definitions

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

Removals

Removal of html-validation and virtual-dom-rs packages

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

Removal of the virtual-node package

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/virtual-node · high confidence

Removed html-macro-test package

The \html-macro-test\ package, which contained unit tests for the \html!\ procedural macro (including tests for text nodes, attributes, and UI error handling), has been deleted along with its documentation.

packages/html-macro-test · high confidence

Architecture

Refactored HTML macro internals into modular source files

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

Refactored autofmt with new internal formatting infrastructure

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

Behavioural changes

1 commit (0 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 1 commit, 13 files: “Eliminate the \dioxus-base-types\ crate (\#6054)” (refs \#6054).

packages/vdom · low confidence · unverified

3 commits (0 fixes) modifying packages/dx

A change to existing behaviour in packages/dx — 3 commits, 125 files: “Split \dx-env\ out of \dioxus-cli-config\ (\#6056)”; “Rename generic \DIOXUS\\\ env vars to \DX\\\ (\#6057)”; “Rename \dioxus-cli-\\ packages to \dx-\\ (\#6055)” (refs \#6056, \#6057, \#6055).

packages/dx · medium confidence · unverified

3 commits (0 fixes) modifying packages/router-macro, packages/vdom-macro

A change to existing behaviour in packages/router-macro, packages/vdom-macro — 3 commits, 17 files: “Rename dioxus-core to dioxus-vdom (\#6021)”; “Add \dioxus-core\ crate and base the dioxus prelude on it (\#6024)”; “Resolve renamed \dioxus\ in vdom-macro and router-macro via proc-macro-crate (\#6023)” (refs \#6021, \#6024, \#6023).

packages/vdom-macro · medium confidence · unverified

4 commits (0 fixes) modifying .devin

A change to existing behaviour in .devin — 4 commits, 2 files: “Publish static musl dx binaries and build Linux gnu binaries on Ubuntu 22.04 (\#6052)”; “Add release-alpha agent skill (\#5928)”; “Rename dioxus-core to dioxus-vdom (\#6021)”; and 1 more (refs \#6052, \#5928, \#6021).

.devin · medium confidence · unverified

Add development toast notifications and separate production HTML template

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

Attribute mutations now use borrowed values

The core diffing engine and mutation system have been updated to pass borrowed attribute values (\BorrowedAttributeValue\) instead of owned \AttributeValue\ instances when applying changes to the DOM. This change affects the \WriteMutations::set\_attribute\ interface across the core, interpreter, and oracle packages, reducing allocation overhead during rendering by avoiding unnecessary cloning of attribute data. Also in this area: New typed view builder system and optimized template storage.

packages/fuzz, packages/oracle · high confidence

Complete rewrite of the HTML crate with typed elements and structured event data

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

Complete rewrite of web event handling to support new dioxus-html event types

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

Const-serialize now uses CBOR format for serialization

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

Core runtime and component model overhaul

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. Also in this area: 2 commits (0 fixes) modifying packages/dioxus; Attribute mutations now use borrowed values.

packages/core/src · medium confidence · unverified

Desktop renderer refactored into a new modular architecture

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

Dioxus Logger integration and documentation update for v0.6

The \packages/logger\ area now includes the README and license files for \dioxus-logger\, documenting its integration into Dioxus v0.6 as a built-in cross-platform logging facade based on \tracing\. The documentation clarifies that for Dioxus v0.6, the logger is included by default and initialized via \dioxus::logger::init\, whereas v0.5 and earlier required adding \dioxus-logger\ as an external dependency. It also notes that runtime filtering for non-wasm targets uses the \RUST\_LOG\ environment variable.

packages/logger · high confidence

Document package asset and build configuration added

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

Empty asset files added to manganis package

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

Generational box storage refactored with improved borrow tracking and error reporting

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

History provider moved to context with in-memory fallback

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

Interpreter now uses TypeScript source with Bun-based build pipeline

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

Introduce template-based SSR with caching and improved security

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

Manganis asset system overhaul with typed options and CSS modules

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

New Android platform bridge with 32-bit support

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. Also in this area: 3 commits (1 fix) modifying packages/manganis; Improved Android activity lifecycle handling for configuration changes.

packages/manganis/manganis/src/android · medium confidence · unverified

New JavaScript interpreter implementation for Dioxus

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

New TypeScript interpreter implementation with streaming hydration and native event support

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

New markerless hydration implementation for streaming Suspense boundaries

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

New modularized RSX hot-reload diffing engine

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

New router hooks and updated navigation API

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

RSX macro parser refactored with improved diagnostics and structured node types

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

Router context API restructured with dedicated Navigator and Outlet contexts

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

Signals crate restructured with new CopyValue and mapped signal types

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

Unified launch API with explicit platform feature selection

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

Fixes

Fixes JavaScript evaluation in the desktop app

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

Test coverage

1 commit adding/updating tests in packages/core/tests, packages/dioxus/tests; 2 commits adding/updating tests in packages/rsx-hotreload/tests/valid; Add Playwright tests for CLI asset optimization and module handling; Added CLI test harnesses for platform and feature resolution; Added SSR test coverage for rendering edge cases; Added benchmark suite for generational box storage operations; 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 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; Expanded test coverage for the autofmt RSX formatter; Updated test suite structure for html-internal-macro.

Dependencies

Initial dependency lockfile and example project manifests

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

Housekeeping

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

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

How this codebase got here

Score

  • CAI 57 → 58 (+1.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 49 → 47 (-1.6)
  • Architecture 96 → 96 (-0.2)
  • Maturity 74 → 75 (+1.2)
  • Readiness 67 → 67 (+0.0)
  • Security 66 → 69 (+2.8)
  • Accessibility 55 → 63 (+7.9)
  • Performance 87 → 87 (+0.0)

Resolved (355)

  • 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)
  • 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 21) (packages/cli/src/build/request.rs)
  • BuildRequest::cargo_build_arguments (cyclomatic 24) (packages/cli/src/build/request.rs)
  • BuildRequest::compile_dep_crate (cognitive 23) (packages/cli/src/build/link.rs)
  • BuildRequest::compile_dep_crate (cyclomatic 17) (packages/cli/src/build/link.rs)
  • BuildRequest::compile_workspace_hotpatch (cognitive 19) (packages/cli/src/build/link.rs)
  • …and 335 more

New (498)

  • AppBuilder::finish_build (cyclomatic 18) (packages/dx/src/build/builder.rs)
  • AppBuilder::get_android_device_transport_id (cognitive 24) (packages/dx/src/build/builder.rs)
  • AppBuilder::get_ios_device_uuid (cognitive 18) (packages/dx/src/build/builder.rs)
  • AppBuilder::wait (cognitive 23) (packages/dx/src/build/builder.rs)
  • AppBuilder::wait (cyclomatic 39) (packages/dx/src/build/builder.rs)
  • AppServer::handle_file_change (cognitive 114) (packages/dx/src/serve/runner.rs)
  • AppServer::handle_file_change (cyclomatic 46) (packages/dx/src/serve/runner.rs)
  • AppServer::wait (cognitive 20) (packages/dx/src/serve/runner.rs)
  • AppServer::watch_filesystem (cognitive 19) (packages/dx/src/serve/runner.rs)
  • AppServer::workspace_dep_chain (cognitive 26) (packages/dx/src/serve/runner.rs)
  • BuildRequest::android_env_vars (cyclomatic 16) (packages/dx/src/build/android.rs)
  • BuildRequest::auto_provision_entitlements (cognitive 27) (packages/dx/src/build/apple.rs)
  • BuildRequest::auto_provision_entitlements (cyclomatic 20) (packages/dx/src/build/apple.rs)
  • BuildRequest::cargo_build (cognitive 27) (packages/dx/src/build/request.rs)
  • BuildRequest::cargo_build (cyclomatic 18) (packages/dx/src/build/request.rs)
  • BuildRequest::cargo_build_arguments (cognitive 21) (packages/dx/src/build/request.rs)
  • BuildRequest::cargo_build_arguments (cyclomatic 24) (packages/dx/src/build/request.rs)
  • BuildRequest::compile_dep_crate (cognitive 23) (packages/dx/src/build/link.rs)
  • BuildRequest::compile_dep_crate (cyclomatic 17) (packages/dx/src/build/link.rs)
  • BuildRequest::compile_workspace_hotpatch (cognitive 19) (packages/dx/src/build/link.rs)
  • …and 478 more

Changes since last survey

  • 16 commits — 14 feature/other, 2 fixes

By area

  • packages/cli — 2 commits
  • packages/dx — 2 commits
  • (root) — 1 commit
  • .github/workflows — 1 commit
  • packages/core — 1 commit
  • packages/dioxus — 1 commit
  • packages/fullstack — 1 commit
  • packages/manganis — 1 commit
  • packages/router — 1 commit
  • packages/router-macro — 1 commit
  • packages/rsx-hotreload — 1 commit
  • packages/stores — 1 commit
  • packages/vdom — 1 commit
  • packages/web — 1 commit

Notable commits

  • fix: fix(fullstack): bubble Bytes::from_request errors instead of panicking (#5803)
  • fix: fix(manganis): stop the Android JNI alias from shadowing Result in the prelude (#6044)
  • change: Add dioxus-core crate and base the dioxus prelude on it (#6024)
  • change: CI: bump stable Rust pin to 1.94.1 (#6070)
  • change: Eliminate the dioxus-base-types crate (#6054)
  • change: Invert dioxus-router's dependency on dioxus-fullstack-core (#6022)
  • change: Publish static musl dx binaries and build Linux gnu binaries on Ubuntu 22.04 (#6052)
  • change: Rename dioxus-cli-* packages to dx-* (#6055)
  • change: Rename dioxus-core to dioxus-vdom (#6021)
  • change: Rename generic DIOXUS_* env vars to DX_* (#6057)
  • change: Resolve renamed dioxus in vdom-macro and router-macro via proc-macro-crate (#6023)
  • change: Split dx-env out of dioxus-cli-config (#6056)
  • change: Upgrade convert_case to 0.12.0 (#6012)
  • change: cli: link Android libraries with 16 KB page alignment (#6051)
  • change: stores: let #[store] methods return impl Trait (#5995)
  • change: web: make dioxus-devtools an optional dependency behind the devtools feature (#6028)

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 97adf7915e1adfef4e2da436c9bd0b6add0dfa39 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.