cloudparts

Dioxus

A React-like Rust UI framework for web, desktop and mobile from one codebase: Rust runs natively on desktop and phones and as WebAssembly in the browser, with a system web view or its own GPU renderer drawing the HTML and CSS.

What it is
Cross-platform desktop apps
Used for
Cross-platform mobile apps,WebAssembly
Type
Open source
Made by
Dioxus Labs
License
MIT or Apache 2.0 (your choice)
Facts checked
24 October 2026
Website Source code

What it is

Dioxus apps are Rust functions that return an rsx! tree, a JSX-like macro for HTML elements styled with CSS (Tailwind support is built in). State lives in signals: use_signal(|| 0) returns a Signal that is Copy, so it moves into event handlers and async tasks without cloning. When a signal changes, the components that read it re-run and a virtual DOM diffs their output, the model React uses, rather than the per-node updates of Leptos or Solid. The same app is launched on each platform by a renderer: on the web, it is compiled to WebAssembly and patches the browser’s DOM; on desktop, the Rust code runs natively and the UI is shown in the system web view through WRY, the library Tauri uses, which keeps a typical app under 5 MB; on Android and iOS it runs the same way inside the platform’s web view.

Dioxus Native, introduced in 0.7 (September 2025), drops the web view: it renders the HTML and CSS with Blitz, Dioxus’s own modular layout and styling engine, and paints with WGPU on the GPU. It is still marked experimental, and not all of CSS is supported. The dx command-line tool serves, bundles and hot-patches apps: since 0.7, Subsecond swaps changed Rust functions into a running app on web, desktop and mobile without losing its state. Full-stack apps add server functions on Axum, server rendering and hydration. The stable line is 0.7; 0.8 is in alpha, with breaking changes and a reworked native renderer.

Why teams pick it

  • One Rust codebase for web, desktop and mobile, with direct calls to native code (Objective-C, JNI, web-sys) where a platform needs it
  • Small desktop apps: the system web view instead of a bundled browser, typically under 5 MB
  • Rust code runs natively on desktop and mobile, so it reaches files, sockets and threads directly rather than through IPC from a web page
  • Subsecond hot-patching of Rust code during dx serve, keeping the app’s state between edits

Watch out for

  • Still 0.x: each minor version breaks APIs, as 0.5 replaced hooks with signals and 0.8 alphas change event types and renderer interfaces
  • On desktop the UI is still a web view, so WebView2, WKWebView and WebKitGTK differences apply, and browser APIs such as WebGL and Canvas are harder to use than on the web
  • Dioxus Native, the web-view-free renderer, is experimental: Blitz is a work in progress and lacks parts of CSS
  • Component-level re-rendering and a virtual DOM do more work per change than fine-grained frameworks such as Leptos, which also focus harder on web bundle size

Alternatives

What all cross-platform desktop apps have in common →Compare side by side →
ElectronOpen sourceA framework for Windows, macOS and Linux apps written in HTML, CSS and JavaScript, which ships its own copy of Chromium and Node.js inside every app; Visual Studio Code runs on it.TauriOpen sourceA framework for desktop and mobile apps with a web front end shown in the operating system’s own web view and a Rust core that holds the app’s logic and its access to the system.

How it fits with other technologies

One component; `dx serve --platform web`, `desktop` or `android` runs it · rust

use dioxus::prelude::*;

fn main() {
    dioxus::launch(app);
}

fn app() -> Element {
    // Signal<i32> is Copy, so it moves into the closures below
    let mut count = use_signal(|| 0);

    rsx! {
        h1 { "High-Five counter: {count}" }
        button { onclick: move |_| count += 1, "Up high!" }
        button { onclick: move |_| count -= 1, "Down low!" }
    }
}

See it in a real stack

No architecture uses Dioxus yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2022–2026

Jonathan Kelley released Dioxus 0.1 on 3 January 2022 as a library for building interactive user interfaces in Rust, to bring static typing to front-end work without JavaScript tooling or undefined-property crashes. It borrowed React’s mental model, a virtual DOM, hooks and a JSX-like rsx! macro, and launched with web, desktop (through a web view), server rendering, very experimental mobile support and a work-in-progress terminal renderer, crediting the Tauri team’s work for making mobile possible.

The project grew from a side project into a small full-time team, supported by FutureWei, Satellite.im and the GitHub Accelerator. Version 0.5, in March 2024, answered the community’s request to “make it simpler”: it removed lifetimes and the cx: Scope argument, and replaced use_state and use_ref with Copy signals. Version 0.7, on 8 September 2025, after more than 350 merged pull requests, added Subsecond hot-patching of Rust code, rebuilt full-stack server functions around Axum, introduced 28 unstyled accessible components modelled on Radix, and shipped the first Dioxus Native renderer on Blitz. In 2026 the 0.8 alphas reworked that renderer and moved the codebase to the 2024 edition.

Why it’s built this way

React’s model in Rust
A virtual DOM, components and a JSX-like macro gave web developers a familiar way to build UIs while keeping Rust’s static types and avoiding JavaScript’s runtime errors.
Renderers, not one target
Separating the component tree from what draws it lets one app run on the web through the DOM, on desktop and mobile through a system web view, on a server as HTML, or on the GPU with Blitz.
Copy signals instead of hooks with lifetimes
Lifetimes scared newcomers off, and async tasks needed 'static values, which forced cloning hooks. Making Signal<T> Copy lets state move into closures and futures directly.
Its own HTML and CSS engine
A system web view brings platform differences and browser overhead. Blitz lets Dioxus lay out and paint HTML and CSS itself, so an app can run without any web view.

Timeline

  1. 2022

    Dioxus 0.1 released on 3 January

  2. 2024

    Dioxus 0.5 replaces hooks with Copy signals in March

  3. 2025

    Dioxus 0.7 adds Subsecond hot-patching and Dioxus Native in September

  4. 2026

    Dioxus 0.8 alphas rework the native renderer

Sources8 · facts checked 24 October 2026

Improve this page on GitHub