Skip to content

Releases: DioxusLabs/dioxus

Dioxus v0.7.0

31 Oct 04:49
@ealmloff ealmloff
v0.7.0
ee25fcb

Choose a tag to compare

View all tags
Dioxus v0.7.0 Latest
Latest

Hot-Patching, Native Renderer, Axum Integration, Bundle Splitting, Radix-UI, more!

Welcome back to another Dioxus release! Dioxus (dye • ox • us) is a framework for building cross-platform apps in Rust. We make it easy to ship full-stack web, desktop, and mobile apps with a single codebase.

Dioxus 0.7 delivers on a number of promises we made to improve Rust GUI, and more broadly, what we call “high level Rust.” Rust has excelled as a tool for building foundational software, but we hope with Dioxus 0.7, it’s one step closer to being suitable for rapid, high-level development.

In this release, we’re shipping some incredible features. The highlights of this release include:

  • Subsecond: Hot-patching of Rust code at runtime
  • Dioxus Native: WGPU-based HTML/CSS renderer for Dioxus
  • Fullstack: Revamp of Server Functions with full Axum integration
  • WASM-Split: Code splitting and lazy loading for WebAssembly
  • Stores: A new primitive for nested reactive state
  • Dioxus Primitives: first-party radix-primitives implementation for Dioxus

Dioxus 0.7 also brings a number of other exciting new features:

  • Automatic tailwind: zero-setup tailwind support built-in!
  • LLMs.txt: first-party context file to supercharge AI coding models
  • Blitz: our modular HTML/CSS renderer powering Dioxus Native, available for everyone!
  • Fullstack WebSockets: websockets in a single line of code
  • Integrated Debugger Support: open CodeLLDB with a single keystroke
  • Fullstack error codes: Integration of status codes and custom errors in fullstack
  • Configurable Mobile Builds: Customize your AndroidManifest and Info.plist

Plus, a number of quality-of-life upgrades:

  • one-line installer ( curl https://dioxus.dev/install.sh | sh )
  • dx self-update and update notifications
  • automatically open simulators
  • Improved log coloring
  • desktop and mobile toasts
  • HTML streaming now waits for the router to render
  • Axum 0.8 and Wry 52 upgrade
  • Android + iOS device support
  • More customization of iOS and Android projects
  • Hash Router Support for dioxus-web
  • Multi-package serve: dx serve @client --package xyz @server --package xyz
  • Support for dyib bundling
  • wasm32 support for fullstack
  • Hashless assets
  • /public dir
  • And many, many bugs fixed!

Rust Hot-patching with Subsecond

The biggest feature of this release: Dioxus now supports hot-patching of Rust code at runtime! You can now edit your Rust code and see changes without losing your app’s state.

We’ve been working on this feature for almost an entire year, so this is a very special release for us. The tool powering this hot-patching is called Subsecond and works across all major platforms: Web (WASM), Desktop (macOS, Linux, Windows), and even mobile (iOS, Android):

hotpatch-android.mp4
ios-binarypatch.mp4

You can now iterate on your app’s frontend and backend simultaneously without skipping a beat.

hotpatch-wasm-complete.mp4

Subsecond works in tandem with the Dioxus CLI to enable hot-patching for any Rust project. Simply run dx serve on your project and all subsecond::call sites will be hot-patched. For example, here’s Subsecond working with a Ratatui app:

subsecond-tui.mp4

The infrastructure to support Subsecond is quite complex. Currently, we plan to only ship the Subsecond engine within the Dioxus CLI itself with a long-term plan to spin the engine out into its own crate. For now, we still want the ecosystem to experience the magic of Subsecond, so we’ve made the CLI compatible with non-dioxus projects and removed “dioxus” branding when not serving a dioxus project.

Screenshot_2025-06-24_at_1 49 07_PM

Hot-patching Rust code is no simple feat. To achieve a segfault-free experience, we recommend framework authors to tie into Subsecond’s minimal runtime. For application developers, you can simply use subsecond::call(some_fn) at clean integration points to take advantage of hot-patching. If you use Dioxus, hot-patching comes directly integrated with components and server functions.

pub fn launch() {
    loop {
        std::thread::sleep(std::time::Duration::from_secs(1));
        subsecond::call(|| tick());
    }
}

fn tick() {
    println!("edit me to see the loop in action!!!!!!!!! ");
}

While in theory we could implicitly override calls to tick with function detouring, we instead chose explicit integration points. The first version of subsecond modified process memory externally, but we struggled with issues where the program would be stuck in a task with no way to “resurface”. For this example, the program would always be waiting for IO, making our edits not take effect:

fn main() {
    loop {
        let next_event = wait_for_io();
        do_thing();
    }
}

Instead, the explicit runtime integration provides a simple “synchronization point” where the framework can handle things like closing TCP connections, re-instancing state, dropping event listeners, etc. If you add or remove a field of a struct between hot-patches, Subsecond does not automatically migrate your state for you. Libraries like bevy-reflect make this easier - and we might integrate reflection at some point - but for now, frameworks should take care to either dispose or safely migrate structs that change.

We expect folks to use Subsecond outside of Dioxus, namely in web development, so we’ve provided a few starter-integrations for popular libraries:

  • Axum
  • Bevy
  • Ratatui

Subsecond has already made its way into popular projects like Bevy and Iced. Right now, you can git pull the latest Bevy and Iced repositories and start hot-patching with zero setup:

bevy-hotpatch.mp4

Hot-patching covers nearly every case in Dioxus. Many tasks that were previously massively burdensome are now a breeze:

  • Adding a new asset!() call
  • Editing strongly-typed interfaces on components like icon variants or links
  • Dynamically adding children to a component
  • Modifying backend server function code
  • Modifying event handler logic - ie onclick or onmouseover
  • Loading resources and async values
  • Refactoring rsx into components

Under the hood, we implemented a form of incremental linking / binary patching tailored for running apps. This is not too distant from the idea laid out by Andrew Kelley for Zig.

Dioxus Native and Blitz

We’re extremely excited to announce the first-ever version of Dioxus Native: our new renderer that paints Dioxus apps entirely on the GPU with WGPU.

Out of the box, it already supports a huge number of features

  • Accessibility integration
  • Event handling
  • Asset fetching and loading.

Dioxus Native required a monumental amount of work, pushing forward

  • HTML/CSS layout and rendering
  • High quality text painting

We’re extremely excited to release Blitz: our modular HTML/CSS rendering engine.

Blitz combines a number of exciting projects to bring customizable HTML rendering engine to everyone. Blitz is a result of collaboration across many projects: Firefox, Google, Servo, and Bevy. We’re leveraging a number of powerful libraries:

  • Taffy: our high-performance flexbox layout engine
  • Stylo: Firefox and Servo’s shared CSS resolution engine
  • Vello: Linebender’s GPU compute renderer

Blitz is an extremely capable renderer, often producing results indistinguishable from browsers like Chrome and Safari:

blitzvssafari

Not every CSS feature is supported yet, with some bugs like incorrect writing direction or the occasional layout quirk. Our support matrix is here: https://blitz.is/status/css

The samples that Blitz can create are quite incredible. Servo’s website:

image

Hackernews:

image 1

The BBC:

Screenshot_2025-03-29_at_2 04 28_PM

We even implemented basic <form /> support, making it possible to search Wikipedia without a full browser:

Screen_Recording_2025-05-24_at_16.21.05.mov

Do note that Blitz is still very young and doesn’t always produce the best outputs, especially on pages that require JavaScript to function properly or use less-popular CSS features:

Screenshot_2025-03-29_at_2 09 14_PM

Blitz also provides a pluggable layer for interactivity, supporting actions like text inputs, pluggable widgets, form submissions, hover styling, and more. Here’s Dioxus-Motion working alongside our interactivity layer to provide high quality animations:

Screen_Recording_2025-01-05_at_7.46.14_PM.mov

Bear in mind that Blitz is still considered a “work in progress.” We have not focused on performance

Dioxus Fullstack Overhaul

We completely revamped Dioxus Fullstack, bringing in a new syntax and a whole host of new features.

To start, we've introduced a new dioxus::serve entrypoint for server apps that en...

Read more

Contributors

davidB, RickWong, and 105 other contributors
Assets 18

v0.7.0-rc.4

31 Oct 02:47
@jkelleyrtp jkelleyrtp
v0.7.0-rc.4
1b81d89

Choose a tag to compare

View all tags
v0.7.0-rc.4 Pre-release
Pre-release

What's Changed

  • Fix the info message for the dx components subcommand by @ealmloff in #4832
  • Native: implement hot-reloading of stylesheets by @nicoburns in #4830
  • fix(hotpatch): Gracefully handle missing '-flavor' flag during WASM link by @luckybelcik in #4833
  • Readable and Writable helpers for String, HashMap and HashSet by @ealmloff in #4834
  • Skip emitting a transposed type if the original type is entirely generic by @ealmloff in #4838
  • fix(cli): correct Android toolchain target for 32-bit arm architectures by @atty303 in #4837
  • Pin tauri-macos-sign by @ealmloff in #4845
  • fix: tokio rt is not set when calling handlers by @jkelleyrtp in #4850
  • use CapturedError as dioxus::Ok() so resources still function as expected by @jkelleyrtp in #4851
  • Fullstack: Fix missing query string on #[get] server functions by @bwskin in #4827
  • restore the extract function for server functions by @ealmloff in #4849
  • Add option_asset! to match asset! by @tekacs in #4791
  • feat: set windows subsytem to windows for gui apps by @jkelleyrtp in #4855
  • Pipe Android/ADB logs into CLI by @wheregmis in #4853
  • Fix updating components and local components by @ealmloff in #4856
  • multiple fullstack nits/cleanups before release by @jkelleyrtp in #4852
  • Relax asset resolver bounds and document resolving folder assets by @ealmloff in #4859
  • Expand relative assets to a placeholder if we are running in rust analyzer by @ealmloff in #4860
  • Add some functions to read/write request header for server functions by @javierEd in #4823
  • Feat: eager loading of assets by @omar-mohamed-khallaf in #4653
  • fix: dx not recognizing [web, server] in default by @jkelleyrtp in #4865

New Contributors

Full Changelog: v0.7.0-rc.3...v0.7.0-rc.4

Contributors

tekacs, atty303, and 8 other contributors
Loading

Dioxus 0.7.0-rc.3

20 Oct 22:20
@jkelleyrtp jkelleyrtp
v0.7.0-rc.3
321032c

Choose a tag to compare

View all tags
Dioxus 0.7.0-rc.3 Pre-release
Pre-release

This release is hopefully the final pre-release before the full 0.7 release!

In this release we:

  • Fixed a critical issue with custom axum routers not injecting wasm/js bootstrap code
  • Added support for /public/ dir, allowing assets without the manganis asset system
  • Added a components command for a shadcn-like components experience
  • Fixed some bugs to unlock hot-patching on the new dioxus playground
  • Moved to pinning dioxus dependencies within the workspace to make it easier to manually upgrade release candidates.

That's about it - hoping to see 0.7 either late this week or early next week!

What's Changed

New Contributors

Full Changelog: v0.7.0-rc.2...v0.7.0-rc.3

Contributors

RickWong, Jasper-Bekkers, and 4 other contributors
Loading

0.7.0-rc.2

15 Oct 08:34
@jkelleyrtp jkelleyrtp
v0.7.0-rc.2
7454fc2

Choose a tag to compare

View all tags
0.7.0-rc.2 Pre-release
Pre-release

This pre-release ships a number of bug fixes for Dioxus 0.7 as well as a handful of new features.

  • File Dialogs and Drag Events have been fixed after being broken in rc-1
  • The Dioxus JS glue is now independent of the window, making it possible to bootstrap webworkers with the primary dioxus wasm bundle
  • A number of fixes related to wasm hot-patching
  • A number of fixes related to mobile and native hotpatching
  • Ability to set response status and headers from within the SSR app
  • Ability to capture errors during SSR and render a fallback UI
  • Fixes for SSR and hydration
  • Middleware support for server functions with #[middleware] attribute
  • use_loader now serializes its contents for hydration
  • drag_and_drop API for web and related xample

What's Changed

New Contributors

Full Changelog: v0.7.0-rc.1...v0.7.0-rc.2

Contributors

tekacs, thyseus, and 4 other contributors
Loading

v0.7.0-rc.1

08 Oct 08:35
@jkelleyrtp jkelleyrtp
v0.7.0-rc.1
05f3b8d

Choose a tag to compare

View all tags
v0.7.0-rc.1 Pre-release
Pre-release

Today, we’re releasing Dioxus 0.7.0-rc.1 - the second pre-release of Dioxus 0.7.

This release unfortunately took much longer to ship than we expected. While fixing bugs related to dioxus fullstack, we stumbled across a handful of critical issues in our integration with the server_fn crate. Coupled with changes in the dioxus CLI, these issues prevented a large swath of user projects from compiling.

As such, we re-implemented the server function crate, but this time exclusively tailored for Dioxus and Axum. This rewrite was originally planned as a major feature of Dioxus 0.8, but given the severity of the issues, we decided to pull it forward to 0.7. The rewrite unlocks tons of new functionality including things like SSE, flexible error types, custom axum routers, simple websockets, and a rocket-like endpoint definition system.

Here's a quick sneak peek:

use dioxus::prelude::*;

fn main() {
    dioxus::launch(|| {
        let mut message = use_action(get_message);

        rsx! {
            h1 { "Server says: "}
            pre { "{message:?}"}
            button { onclick: move |_| message.call("world".into(), 30), "Click me!" }
        }
    });
}

/// you can now encode query and path parameters in the macro!
#[get("/api/{name}/?age")]
async fn get_message(name: String, age: i32) -> Result<String> {
    Ok(format!("Hello {}, you are {} years old!", name, age))
}

Rust-Conf keynote

I gave a keynote talk at Rust Conf! Check it out! It covers the various projects we've been working on to push Rust forward, including subsecond hot-patching, progress on autoclones in Rust, and more.

Screenshot 2025-10-08 at 1 25 22 AM

Changes to Fullstack

We completely overhauled dioxus-fullstack, fixing a huge number of long-standing bugs and adding tons of new functionality.

These include:

  • New macros for annotating API endpoints (#[get("/api/route")], #[post("/api/:path?query&param")] )
  • Accept pure axum handlers that take FromRequest and IntoResponse bodies
  • Server-only FromRequest extractors
  • A new HttpError type and accompanying trait for returning proper Axum responses
  • Support for anyhow::Error type as a return type from server functions
  • Addition of a Server-Sent-Events (SSE) type
  • Addition of a Websocket type and reactive use_websocket hook for handling websocket connections
  • Addition of a MultipartFormData type that works across web and native
  • Addition of a Streaming<T, E> type without needing to specify an encoding attribute
  • Support for custom encoding types
  • Access to the full axum::extract::Request type in server functions
  • Support for pure SSR apps with hot-reloading powered by subsecond
  • Support for custom axum routers with dioxus::serve
  • Support for Lazy<T> type for lazy async initializers

As mentioned earlier, the fullstack overhaul was originally planned for Dioxus 0.8, but we decided to pull it forward into 0.7, causing a substantial delay.

To get a feel for the new APIs, take a look at the fullstack examples folder. We will be updating fullstack docs this week to prep for the full 0.7 release soon.

Breaking changes to Events: FormData and FileData

Our Form and File APIs have been clumsy for quite a while. In order to support ergonomics improvements with server functions, we revisited our FormData and FileData APIs to make them more consistent with the web platform.

We replaced the old FilesEngine abstraction with a new FileData type with an API that matches the browser.

In addition, we changed how to read the field names and values from forms. Previously, .values() return a HashMap of form values, but now, .values() returns a Vec of form values - again, to better match web APIs.

Breaking changes to dioxus::core APIs

A number of APIs were moved from ScopeId to the Runtime in dioxus_core. This shouldn't impact most users, but anyone building a renderer around Dioxus will notice that some methods no longer exist.

These were changed to reduce our API surface area outside of core types like Runtime and to make it easier to understand where runtime-related errors were occurring.

Updates to Blitz

Blitz saw massive improvements over the past few weeks, notably with the addition of incremental tree construction which makes Blitz substantially faster. Now, Blitz performance is on-par with the Rust GUI ecosystem.

What's Changed

Read more

Contributors

dabrahams, kristoff3r, and 19 other contributors
Loading

Dioxus 0.7.0-rc.0

11 Aug 23:11
@jkelleyrtp jkelleyrtp
v0.7.0-rc.0
a8230d8

Choose a tag to compare

View all tags
Dioxus 0.7.0-rc.0 Pre-release
Pre-release

Final Preparation for Dioxus 0.7!

In this final pre-release, we fixed a number of bugs and made a number of improvements in preparation for Dioxus 0.7 release.

The only things left for release are:

  • release video
  • (time-willing) wire up the playground to the subsecond hotpatching engine.

In this release, we fixed a number of issues and add a few new features:

  • The new Stores API adds wrappers for Signal<Vec>, Signal<HashMap>, and custom "store" structs for simpler state management.
  • Many new pages of docs related to building UIs and reactivity.
  • Hotpatching is now more reliable, allowing you to break the rules of hooks during development
  • New shorthands for platforms. IE dx serve --ios instead of dx serve --platform ios
  • You can select different renderers (native vs webview) from the CLI
  • A new example showcasing how to embed dioxus-native in a bevy app
  • We removed the dioxus-lib crate due to low adoption in favor of dioxus with the "lib" feature
  • A new nix flake makes installing dx easier on nix platforms
  • We manage openssl prebuilt when targetting android to make it easier for windows users to build android apps
  • Blitz has been updated to support named grid sections and other new features
  • RSX autoformatting respects comments in many more situations including expressions
  • Many bug fixes related to subsecond hotpatching
  • New methods for loading assets from the application bundle directly
  • We renamed .dioxus to .dx in prep for the DX spin-out
  • Linux asset bundling is fixed after changes to the underlying appimage bundler broke
  • The CLI now collects crash-reports and some basic opt-out anonymized telemetry

Expect the full 0.7 release either this week or next!

Loading

v0.7.0-alpha.3

17 Jul 00:46
@jkelleyrtp jkelleyrtp
v0.7.0-alpha.3
f9e7011

Choose a tag to compare

View all tags
v0.7.0-alpha.3 Pre-release
Pre-release

Lots of bug fixes, prep for 0.7 release

This release fixes a huge number of bugs (around 50-60!) and brings better stability to Dioxus in prep for the 0.7 release.

We're finishing up release materials and have a few more small items for rc-0, but 0.7 is feature-complete and thoroughly tested.

What's Changed

  • fix: allow to name module std in project by @davidB in #4353
  • Add a bevy-texture example based on wgpu-texture by @jerome-caucat in #4360
  • Native: Accept winit::WindowAttributes as a config value by @nicoburns in #4364
  • Fix router state after client side navigation by @ealmloff in #4383
  • Native: Split dioxus-native-dom crate out of dioxus-native by @nicoburns in #4366
  • Add PartialEq and Eq derives to ServerFnError by @Himmelschmidt in #4393
  • fix(bundle): add serde defaults to prevent deserialization errors by @rennanpo in #4398
  • prevent_default must be called synchronously or it will have no effect by @LilahTovMoon in #4386
  • final 0.7 fixes: xcode 15/16 hybrid, auto openssldir for android, include_*! tracking hotpatch, fix /assets/ brick at high opt levels, windows linker file, etc by @jkelleyrtp in #4376
  • Fixed touch input it will now serialize the touchlist by @bananabit-dev in #4406
  • updated the dependencies - maintaining compatibility and tests by @debanjanbasu in #4363
  • Reconnect the edits websocket if it disconnects by @ealmloff in #4391
  • fix link opening on mobile by @jkelleyrtp in #4415
  • Warn about assets being stripped if strip is true and the current package depends on manganis by @ealmloff in #4400
  • Example of rendering a dioxus-native app to a texture by @nicoburns in #4365
  • fix unicode characters in line printing by @jkelleyrtp in #4420
  • Prevent desktop reloads at the wry level by @ealmloff in #4422
  • Capture the rustc environment and project it into run by @jkelleyrtp in #4421
  • fix: don't eat comments in more situations by @jkelleyrtp in #4423
  • Avoid the accidental removal of comments inside expressions by dx fmt by @jjvn84 in #4410
  • clean up prelude by @jkelleyrtp in #4416

New Contributors

Full Changelog: v0.7.0-alpha.2...v0.7.0-alpha.3

Contributors

davidB, nicoburns, and 9 other contributors
Loading

Dioxus v0.7.0-alpha.2

02 Jul 08:50
@jkelleyrtp jkelleyrtp
v0.7.0-alpha.2
d5bc480

Choose a tag to compare

View all tags
Dioxus v0.7.0-alpha.2 Pre-release
Pre-release

Fixes, full Radix Primitives, --device support, --offline/--locked, wry 0.52, LLVM20, hashless assets

Sorry for the delay! Went on a meditation retreat for 10 days 😊

This release fixes a huge number of bugs and improves ergonomics in a bunch of areas.

Notably:

  • Upgraded to the latest wry, which solves many upstream issues
  • Fixing wasm-related issues caused by breaking upstream changes in Rust 1.87 with LLVM20
  • Support for dx serve onto iOS devices
  • Finished the entire set of Radix Primitives and uploaded to the docsite https://dioxuslabs.com/components
  • Fix issues with some memory leaks
  • Fix a number of bugs with subsecond hot-patching
  • Added support for WGPU canvas in dioxus-native
  • Add a dx run command with better CI integration
  • Add a hash history option for dioxus-web
  • Unbrand dx when not serving dioxus projects (good for folks using dx just for subsecond)

Demos

Dioxus-native canvas:

Screen_Recording_2025-06-14_at_02.16.49.mp4

Unbrand dx:

Screenshot 2025-06-24 at 1 48 45 PM

Dioxus Primitives:

Screenshot 2025-06-25 at 1 16 15 PM

What's Changed

New Contributors

Full Changelog: v0.7.0-alpha.1...v0.7.0-alpha.2

Contributors

StudioLE, hecrj, and 20 other contributors
Loading

Dioxus v0.7.0-alpha.1

31 May 22:38
@jkelleyrtp jkelleyrtp
v0.7.0-alpha.1
662cf0d

Choose a tag to compare

View all tags
Dioxus v0.7.0-alpha.1 Pre-release
Pre-release

Fixes, blitz update, and subsecond custom linker setup

This release fixes a number of issues found in Dioxus v0.7.0-alpha.0.

A few updates include

  • better support for custom linkers with the subsecond hotpatching engine
  • updating to blitz 0.1-alpha.1 which fixes bugs, performance, and adds more CSS compatibility
  • arm64 linux binstall builds
  • component library demo site (http://dioxuslabs.github.io/components/)
  • fix wasm-opt with rust 1.87
  • fix vcs in dx new
  • add support for dylib/so/dll bundling
  • fix tls binding across hotpatch boundaries
  • fix lld/mold flags with subsecond
  • hash assets outside the asset!() macro, instead during dx build

Random updates

TODOs before final release

  • Crash analytics monitoring #4224
  • WGPU canvas PR #3979
  • Offline support #4155
  • Error type unification #4205
  • Prelude cleanup
  • More bug fixes
  • Cleaning up PR queue
  • SDK Release
  • Component library release
  • Blog posts
Loading

Dioxus v0.7.0-alpha.0

14 May 08:25
@jkelleyrtp jkelleyrtp
v0.7.0-alpha.0
fa012f3

Choose a tag to compare

View all tags
Dioxus v0.7.0-alpha.0 Pre-release
Pre-release

Note

These release notes are a draft for the full release and thus are incomplete. Not all features might be merged yet!
We are releasing v0.7.0-alpha.0 with many docs and features incomplete, please be patient while we fill everything out.

The current most recent alpha is alpha-3, available at https://github.com/DioxusLabs/dioxus/releases/tag/v0.7.0-alpha.3

Hot-patching, Native, Bundle Splitting, Radix-UI, more!

Welcome back to another Dioxus release! If you’re new here, Dioxus (dye • ox • us) is a framework for building cross-platform apps in Rust. We make it easy to ship fullstack web, desktop, and mobile apps with a single codebase.

Dioxus 0.7 delivers on a number of promises we made to expand the capabilities of Rust GUI. Mature frameworks like Flutter and React Native sport capable hot-reload systems, popular component frameworks, and render natively. Now, Dioxus is on par with the “state of the art”, and in many ways, is even better.

In this release, we’re shipping some incredible features. The highlights of this release include:

  • Dioxus Native: WGPU-based HTML/CSS Dioxus renderer built on Firefox’s Gecko engine
  • Subsecond: Hot-patching of Rust code at runtime
  • WASM-Split: Code splitting and tree shaking for WebAssembly
  • Dioxus-UI: Shadcn-UI implementation for Dioxus

Dioxus 0.7 also brings a number of other exciting new features:

  • Automatic tailwind: zero-setup tailwind support built-in!
  • LLMs.txt: first-party context file to supercharge AI coding models
  • MCP Server: add context, resources, and tools to VSCode, Cursor, and Claude
  • Blitz: our modular HTML/CSS renderer powering Dioxus Native, available for everyone!
  • Dioxus Playground: online WASM/WASI playground with integrated hot-patching
  • Fullstack WebSockets: websockets in a single line of code
  • Integrated Debugger Support: open CodeLLDB or nvim DAP with a single keystroke
  • Fullstack status codes: Integration of status codes and custom errors in fullstack
  • Configurable Mobile Builds: Customize your AndroidManifest and Info.plist

Plus, a number of quality-of-life upgrades:

  • one-line installer ( curl -sSL http://dioxus.dev/install.sh | sh )
  • dx self-update and update notifications
  • automatically open simulators
  • dx compatibility with non-dioxus projects
  • Better log coloring
  • desktop and mobile toasts
  • improved website landing page and migration to http://dioxus.dev hostname
  • Reduced flicker on CSS hot-reloads
  • HTML streaming now waits for the router to render
  • Axum 0.8 upgrade

And many, many bugs fixed:

  • Issues with synchronous multi-window
  • Tab focusing
  • Hot-reloaded assets not being re-processed

Note from the author

Dioxus 0.7 marks the second anniversary of me (Jonathan Kelley) going full time on Dioxus. How time flies! In the past two years we shipped so much:

  • Template Hot-Reloading and Autoformatting
  • Migration to Signals
  • First-party Android and iOS tooling
  • Server Function integration
  • Linker-based asset system
  • and so much more!

The road here has been long and frankly, lots of work. When we started out, the Rust ecosystem had very few good solutions to the basic problems in application development. Even now, the Rust hotpatching and native renderers - while incredible achievements on their own - are just “par for the course” for application development.

With Dioxus 0.7, I feel like the Dioxus foundations are finally solid. We have excellent developer tools, lightning-fast hotpatching, a great asset system, a solid RPC solution, bundle splitting, automatic optimizations, autocomplete, autoformatting, a capable state management solution, comprehensive docs, and funding for the foreseeable future. It’s always nice to see that decisions to adopt industry-standard tech pay-off (Rust GUIs in 2025 article).

What of the future? I finally feel like we’re on the “other side” of the once-impossible problems. With hot-patching and the native renderer behind us, we’re quite free to work on smaller projects. We could definitely use better marketing, more tutorial videos, better starter templates, and ecosystem growth (native APIs in 0.8!). Thanks for all the support so far!

Rust Hot-patching

The biggest feature of this release: Dioxus now supports hot-patching of Rust code at runtime! You can now iterate on your app’s frontend and backend simultaneously without skipping a beat.

We’ve been working on this feature for almost an entire year, so this is a very special release for us. The tool powering this hot-patching is called Subsecond and works across all major platforms: Web (WASM), Desktop (macOS, Linux, Windows), and even mobile (iOS, Android):

ios-binarypatch.mp4
hotpatch-android.mp4

Subsecond works in tandem with the Dioxus CLI to enable hot-patching for any Rust project. Simply run dx serve on your project and all subsecond::call sites will be hot-patched. For example, here’s Subsecond working with a Ratatui app:

subsecond-tui.mp4

The infrastructure to support Subsecond is quite complex; consequently, we plan to only ship the Subsecond engine within the Dioxus CLI itself. However, we still want the ecosystem to experience the magic of Subsecond, so we’ve done two things:

  • Make dx a standalone runner, not tied to Dioxus
  • Integrated hotpatching with our new Dioxus Playground

Hot-patching Rust code is no simple feat. To achieve a segfault-free experience, we recommend framework authors to tie into Subsecond’s minimal runtime. For application developers, you can simply use subsecond::call(some_fn) at clean integration points to take advantage of hot-patching. If you use Dioxus, hot-patching comes directly integrated with components and server functions.

pub fn launch() {
    loop {
        std::thread::sleep(std::time::Duration::from_secs(1));
        subsecond::call(|| tick());
    }
}

fn tick() {
    println!("edit me to see the loop in action!!!!!!!!! ");
}

While in theory we could implicitly override calls to tick with function detouring, we instead chose explicit integration points. Hot-patching encounters a significant challenge with changes to struct layout and alignment, and implicit patching exacerbates these safety issues. Explicit integration provides an opportunity frameworks to “re-instance” changed structs and guarantees a segfault-free experience at the cost of losing some runtime state.

We expect folks to use Subsecond outside of Dioxus, namely in web development, so we’ve provided a few starter-integrations for popular libraries:

  • Axum
  • Bevy
  • Ratatui

Hot-patching covers nearly every case in Dioxus - there’s so much you can hot-reload:

Under the hood, we implemented a form of incremental linking / binary patching tailored for running apps. This is not too distant from the idea laid out by Andrew Kelley for Zig. We have yet to release an in-depth technical writeup about how Subsecond works, but if you’re really interested, come join us at the Seattle RustConf and learn about it during our talk!

Dioxus Native

blitzvssafari

WASM Bundle Splitting and Lazy Loading

bundle-split.mp4

Component Library: Radix Primitives and ShadCN-UI

LLMs.txt, Cursor Rules, MCP Server, and Vibe-Coding

DioxusLabs/docsite#467

vibe-code-2.mp4

Automatic Tailwind

  • dx now detects a tailwind.css file in the root of your crate
  • customize the input and output files in your dioxus.toml
  • Automatically downloads the tailwind binary in the background
tailwind-inline.mp4

Blitz 0.1

We’re extremely excited to release Blitz: our modular HTML/CSS rendering engine.

Blitz combines a number of exciting projects to bring customizable HTML rendering engine to everyone. Blitz is a result of collaboration across many projects: Firefox, Google, Servo, and Bevy. We’re leveraging a number of powerful libraries:

  • Taffy: our high-performance flexbox layout engine
  • Stylo: Firefox and Servo’s shared CSS resolution engine
  • Vello: Google’s GPU compute renderer

Blitz is an extremely capable renderer, often producing results indistinguishable from browsers like Chrome and Safari:

Not every CSS feature is supported yet, with some bugs like incorrect writing direction or the occasional layout quirk. Our support matrix is here: https://blitz-website.fly.dev/support-matrix

The samples that Blitz can create are quite incredible. Servo’s website:

blitz-servo

Hackernews:
blitz-hn

The BBC:

blitz-bbc

Do note that Blitz is still very young and doesn’t always produce the best outputs, especially on pages that require JavaScript to function properly or use less-popular CSS features:

Blitz also provides a pluggable layer for interactivity, supporting actions like text inputs, pluggable widgets, form submissions, hover styling, and more. Here’s Dioxus-Motion working alongside our interactivity layer to provide high quality animations:

Bear in mind that Blitz is still considered a “work in progress.” We have not focused on performance

Integrated Debugger

To date, debugging Rust ...

Read more
Loading