Framework
DioxusLabs/dioxus avatar
DioxusLabs/dioxus

Dioxus 0.7: A Rust fullstack framework that trades ecosystem age for one-codebase reach

GitHub describes it as Fullstack app framework for web, desktop, and mobile.. The repository metadata lists Rust as its primary language. The metadata lists the Apache-2.0 license. This article stays within the project description and details documented in the GitHub repository README.

39,776 stars1,971 forksRustApache-2.0

At a glance

What is it?
Dioxus lets you build web, desktop, and mobile apps from a single Rust codebase, with hot reloading and server functions. It is fast to start but carries real trade-offs in maturity and platform depth.
Who is it for?
Adopt Dioxus if you are a Rust team that wants one language and one component model across web, desktop, and mobile, and you accept the alpha-level churn of 0.8 and the thinness of mobile support. Avoid it if you need production-grade native mobile widgets, a large plugin ecosystem, or a stable API.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • DioxusLabs/dioxus39,776 ★ · +1,111
Star history
Repository2026-08-132026-11-15
DioxusLabs/dioxus38.7k39.8k

1,111 Stars in the last 94 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What Dioxus actually targets

Dioxus is a Rust framework for building user interfaces that run on web, desktop, and mobile from a single codebase. The README claims three lines of code get you cross-platform, which is marketing shorthand, but the core promise is real: you write components once and render them to the DOM via WebAssembly, to a native webview on desktop, or on mobile. The intended user is a Rust developer who wants to avoid JavaScript entirely and who is willing to accept a framework that is younger than React or Svelte. The project is not a toy. It has a full-time core team funded by FutureWei, Satellite.im, and the GitHub Accelerator program, which is a concrete fact from the README. The framework also positions itself as a fullstack solution, not just a UI library, by integrating with axum for server-side rendering, server functions, and a range of built-in features.

Signals and the rsx! macro: the core mechanism

State management in Dioxus centers on signals. The README's counter example shows the pattern: `use_signal(|| 0)` creates a reactive value, and reading `{count}` in the markup subscribes the component to changes. Mutating the signal with `count += 1` triggers a re-render. This is a fine-grained reactivity model, similar in spirit to SolidJS. The `rsx!` macro is the JSX analogue. It compiles to a tree of elements and event handlers. The example attaches `onclick` handlers that move the signal into the closure, which is idiomatic Rust. The README claims this combines the best of React, Solid, and Svelte, which is a strong claim, but the mechanism is clear: declarative markup plus reactive signals. The README claims a hello world of about 50kb on web.

Getting started: dx CLI, serve, and bundle

The primary entry point is the `dx` command-line tool. The README gives two commands: `dx serve` runs the app in development with hot reloading, and `dx bundle` produces deployable artifacts for web, macOS, Linux, and Windows. For mobile, `dx serve --platform android` launches the app in an emulator or on a device. The CLI also has an experimental `dx serve --hotpatch` that updates Rust code in real time, which is a different mechanism from asset hot reloading. The README mentions zero-config setup. The bundler handles web optimizations like `.avif` image generation, `.wasm` compression, and minification. The core workflow is: `dx serve` for development, `dx bundle` for shipping.

Fullstack via axum: where the depth actually is

Dioxus does not just render UI. It integrates deeply with axum, a Rust web framework, to provide server-side rendering, server functions, WebSockets, SSE, streaming, file upload and download, forms, middleware, and hot reload. This is a meaningful difference from a pure client-side framework like Yew. Server functions let you write Rust code that runs on the server and call it from the client, with type safety across the boundary. The README says you can go fully custom and integrate an existing axum backend, which means Dioxus does not force its own server stack. The trade-off is that you need to know axum to use the fullstack features well.

The experimental native renderer and mobile reality

The README is honest about the experimental status of the native renderer. It mentions a WGPU-based renderer that can be embedded in Bevy or run on embedded Linux. That is a long way from a stable desktop or mobile UI. For desktop, the default is a webview, which means you are not rendering native widgets. For mobile, the README says you can call into JNI and native APIs, but the README says apps are styled with HTML and CSS. This is a genuine limitation if you need a platform-native look and feel. The claim that Dioxus is the fastest way to build native mobile apps with Rust is only true if you accept a webview as native. The README labels the native renderer experimental. For teams that need pixel-perfect native controls, Dioxus is the wrong tool today.

Bundling and size: what the numbers actually mean

The README makes two size claims: web apps under 50kb and desktop or mobile apps under 5mb. The 50kb figure is for a hello world, and it is comparable to React, not better. The 5mb desktop figure is plausible for a webview wrapper.. The bundler is a real feature: `dx bundle` handles packaging for web, macOS, Linux, and Windows. On web, it also does `.avif` generation and `.wasm` compression, which are concrete optimizations. The README links to a tiny-dioxus example to support the size claim, but that is a minimal app, not a representative one. If you need to ship a tiny binary, Dioxus can get you there, but only if you avoid heavy dependencies.

Maintenance and upgrade cost: alpha churn and license

The repository shows active development, with v0.8.0-alpha.3 released on 2026-10-16 after alpha.1 and alpha.2. The project is pushing forward on the 0.8 alpha line. The README's own examples are for the 0.7 line, and the tutorial is versioned at 0.7. Upgrading from 0.7 to 0.8 will likely require code changes. The license is Apache-2.0, which is permissive and allows commercial use, but you should check the specific dependency licenses in your project. The community is active, with a Discord and a community-run SDK, but the core team is small and funded by sponsors, which means the project's direction depends on a few people. The README states a long-term goal of paid enterprise tools, so the open-source core may not get all features first. Before adopting, you should verify that the version you target is stable enough for your release cycle.

Editorial conclusion

Adopt Dioxus if you are a Rust team that wants one language and one component model across web, desktop, and mobile, and you accept the alpha-level churn of 0.8 and the thinness of mobile support. Avoid it if you need production-grade native mobile widgets, a large plugin ecosystem, or a stable API. Before committing, verify that your target platform is covered by the current renderer list, test the hotpatch path on your codebase, and check whether the axum integration covers the server features you need, because the README promises WebSockets, SSE, and streaming through its axum integration.

Frequently asked questions

Is Dioxus faster than React?

The README's comparison to React is about bundle size, not runtime speed: the platforms table describes a simple hello world at about 50kb and calls that comparable to React, and the bundler section quotes web apps under 50kb.

Is Dioxus WASM?

It depends on the target. Web builds render directly to the DOM using WebAssembly, desktop uses a webview, and other renderers include server side rendering, liveview, and an experimental WGPU based renderer.

how to install dioxus cli

The README links to the crate page on crates.io and to dioxuslabs.com, where the tour and tutorial are linked, and the commands it gives are dx subcommands such as dx serve or dx bundle.

what is dioxus fullstack

It is the axum-backed server side of the framework. Dioxus integrates with axum, exposes Server Functions for client calls, and ships built-in WebSockets, SSE, Streaming, File Upload and Download, Server-Side-Rendering, Forms, Middleware, and Hot-Reload, or lets you integrate your existing axum backend.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/dioxuslabs-dioxus.svg)](https://hysenlabs.com/projects/dioxuslabs-dioxus)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/dioxuslabs-dioxus.svg)](https://hysenlabs.com/projects/dioxuslabs-dioxus)

Was this useful?