Skip to content

Releases: DioxusLabs/dioxus

v0.7.5

06 Apr 17:57
@jkelleyrtp jkelleyrtp
v0.7.5
d027e26

Choose a tag to compare

View all tags
v0.7.5 Latest
Latest

Dioxus v0.7.5

This release fixes a critical issue where Dioxus wouldn't compile if your Cargo.lock specified too-old versions dependencies like futures-unordered. This was caused by the Dioxus Cargo.toml specifying versions like futures="0.3" when in fact 0.3.32 was required.

Note that the dioxus crate was not updated - only its dependencies that use these versions - so we recommend running cargo update manually.

We also fixed a few other bugs related to hotpatching, autoformatting, and bundling.

What's Changed

  • fix(autofmt): remove extra whitespace before commas in for-loop tuple patterns by @costajohnt in #5384
  • fix(server): don't redirect error responses from #[get] server functions by @costajohnt in #5429
  • Forward -B linker search path in thin/patch link args on Linux by @Wilovy09 in #5443
  • Add support for aarch64 Windows platform in wasm_opt by @hadeutscher in #5442
  • Fixed issue #5438: Added FIPS Compliance flag to candle.exe command by @MasterTemple in #5439
  • Check minimum versions in CI by @ealmloff in #5437

New Contributors

Full Changelog: v0.7.4...v0.7.5

Contributors

hadeutscher, costajohnt, and 3 other contributors
Assets 18

v0.7.4

28 Mar 00:06
@jkelleyrtp jkelleyrtp
v0.7.4
fff2e3d

Choose a tag to compare

View all tags
v0.7.4

Dioxus 0.7.4

This release adds a few new features and fixes several bugs:

  • You can now customize all aspects of iOS and Android builds via Dioxus.toml. We are still updating docs on how this works, but for now, you can reference the new toml schema on which fields are available. https://github.com/DioxusLabs/dioxus/blob/main/packages/cli/schema.json
  • We have added a new FFI interface for Kotlin, Java, and Swift. We plan to add TS/JS next. This automatically bundles relevant source files into your project and generates Rust interfaces, making it easy to write native plugins.
  • We now support bundling iOS widgets, enabling things like live-activity support.
  • We have fixed, tested, and improved dx bundle by vendoring and inlining the tauri bundle code which we previously relied on. This properly sets paths for assets, fixing some long-standing bugs.
  • Many bugs and panics have been fixed! See "what's changed" for more.

What's Changed

New Contributors

Full Changelog: v0.7.3...v0.7.4

Contributors

Infinoid, martinmr, and 23 other contributors
Loading

v0.7.3

17 Jan 03:53
@jkelleyrtp jkelleyrtp
v0.7.3
22b06ba

Choose a tag to compare

View all tags
v0.7.3

This release fixes a large number of bugs.

We added a few new features:

  • Add auxclick, scrollend evnts
  • Support for server-only extractors
  • Scoped CSS and CSS modules 🎉 #5087

What's Changed

New Contributors

Full Changelog: v0.7.2...v0.7.3

Contributors

tekacs, kevinwright, and 24 other contributors
Loading

v0.7.2

05 Dec 04:23
@jkelleyrtp jkelleyrtp
v0.7.2
8f8b58e

Choose a tag to compare

View all tags
v0.7.2

This release fixes a number of issues since the 0.7.1 release.

  • Drag and drop serialization issues
  • Deadlock in sync stores
  • Windows self-update
  • Windows hot-patch cdylib issues
  • WASM hotpatch wbg_cast symbols causing reference to null or undefined symbol
  • macos codesigning
  • Issues with Linux windows
  • Issues with strip setting
  • Issues with fullstack streaming missing frames
  • Linux musl builds

What's Changed

New Contributors

Full Changelog: v0.7.1...v0.7.2

Contributors

binarypie, nicoburns, and 16 other contributors
Loading

v0.7.1

06 Nov 19:43
@jkelleyrtp jkelleyrtp
v0.7.1
03ab7fa

Choose a tag to compare

View all tags
v0.7.1

Post-Release Bug Fixes

This release fixes a number of critical bugs that slipped through v0.7.0 testing.

Namely:

  • Changes related to windows-app builds causing entrypoint symbol to be wrong
  • Fixes some unwrap() calls that were supposed to be errors
  • Use serde_qs for query string support in server functions
  • Tracing spans are properly aligned for server functions
  • Calls to extract() use a blank GET request when called outside the runtime
  • File dialogs on desktop are now async instead of sync
  • The --platform flag was accidentally removed completely, it is now back

We recommend updating with cargo binstall dioxus-cli@0.7.1 --force or dx self-update

What's Changed

New Contributors

Full Changelog: v0.7.0...v0.7.1

Contributors

davidB, Craig-Macomber, and 8 other contributors
Loading

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

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
Loading

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