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

> [!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.

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 [[dioxus.dev/install.sh](http://dioxus.dev/install.sh)](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 [`[dioxus.dev](http://dioxus.dev/)`](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):


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:


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.

```rust
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

## WASM Bundle Splitting and Lazy Loading

## Component Library: Radix Primitives and ShadCN-UI

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

## 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

## 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:


Hackernews:


The 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 apps with VSCode hasn’t been particularly easy. Each combination of launch targets, flags, and arguments required a new entry into your `vscode.json` or `nvim.dap` file. With Dioxus 0.7, we wanted to improve debugging and now ship an integrated debugger. Simply press `d` and the current LLDB / DAP instance will attach to the app running under `dx serve`. By default, LLDB provides rather cryptic names and values while debugging, so we’ve built a prettifier that improves the rendering of Enums and Signals in the debugger.


The integrated debugger works with VSCode and DAP setups and can be used to debug both the server and client simultaneously.

## Improved Version Management Experience

- one-line installer ( curl [[dioxus.dev/install.sh](http://dioxus.dev/install.sh)](http://dioxus.dev/install.sh) | sh )
- `dx self-update` and update notifications

## Various Quality of Life Upgrades

- automatically open simulators
- Better log coloring
- desktop and mobile toasts
- Reduced flicker on CSS hot-reloads

Axum 0.8 Upgrade and Fullstack Improvements

- HTML streaming now waits for the router to render
- Axum 0.8 upgrade

## Playground and Migration to `dioxus.dev`

## Fullstack WebSockets, improved HTML streaming, and custom Error types

## ADB Reverse Proxy for Device Hot-Reload

## DX Compatibility with *any* project

Dioxus’ `dx` tooling is now usable with any Rust project, not just Dioxus projects. You can use `dx` alongside many of the popular Rust projects.

- Hot-Reload
- Packaging/Bundling for Web/Desktop/Mobile
- Assets / Mangnais

Customize AndroidManifest.xml and Info.plist

- pass in your own
- or configure them via our top-level config for both

## iPad Support

## Hot-Dog Tutorial
