Hauke Jung has run Dioxus fullstack in production for a year, across two products, as a solo developer. His summary is the most useful sentence in the post: the Rust code is the most boring part of the business. CI is the most exciting part, and not in a good way.
The numbers are the argument. A release build takes about 90 minutes on a GitHub-hosted two-core runner. The WebAssembly build alone — one leaf crate, the dashboard compiled for the browser — takes about 22 minutes on six cores. cargo clippy --workspace --all-targets got OOM-killed on the 7 GB runner with exit code 143 and no diagnostics; the fix was a 10 GB swapfile and CARGO_BUILD_JOBS=1. His linter needs swap.
That is the bill for "one language, all the way down," and it is itemised.
What the bill changes
The interesting part isn't the compile time itself. It's what a 90-minute build does to engineering behaviour.
He stopped building images on every push to main. Releases now build on tags or by hand, because 90 billed minutes per push is silly money. That's a rational decision, and it quietly changes the development loop: fewer deploys, later integration, a bigger gap between "merged" and "running."
Then there's the cache trap, which is almost a parable. Swatinem/rust-cache works, but a workflow can only restore caches from its own ref or the default branch, and GitHub evicts caches unused for seven days. So once he stopped building on main, release builds started cold. The workaround: after a dependency bump, manually trigger a build on main just to keep the cache warm. A human ritual invented to satisfy a cache eviction policy.
Self-hosting the runner cut the build from 90 minutes to about 40, which is the biggest single win in the post. It also means he now maintains a build server. Every optimisation moved cost from CI minutes into something else — maintenance, or process, or attention.
What he got for it
It would be easy to read this as "Rust fullstack doesn't work." That's not what the post says.
The wins are real and specific. One toolchain, one formatter, one place to look. A struct defined once, returned by the database layer, sent by the server function, rendered by the component — rename a field and cargo check lists every place that broke, UI included. No OpenAPI regeneration, no TypeScript interface drifting out of sync.
His framing of why that matters is better than the usual "developer productivity" line: the win isn't writing code faster, it's refactoring without fear, late at night, with nobody to review it. For a solo founder, that's the whole ballgame. And production is boring — the class of "undefined is not a function" bugs never reaches users, so what's left is logic bugs.
Those benefits don't show up in a build-time benchmark. The costs do. That asymmetry is why these debates go badly.
The asterisk
The business logic is all Rust. The edges aren't. Charts are Chart.js from a CDN, wrapped in about 340 lines of JavaScript. Styling is Tailwind, so CI installs Bun and runs the Tailwind CLI before Rust starts compiling.
He's fine with that, and so am I. But it's worth being precise: "all Rust" is a direction, not a state. Every fullstack framework has an escape hatch, and the honest ones document it.
The counter-bet
His next project uses Topcoat, a new framework from the tokio-rs organisation. It makes the opposite bet: everything renders on the server, components are async functions that query the database directly, and interactivity is written as $(...) expressions in ordinary Rust — evaluated on the server for the first render, translated to JavaScript for the browser. No WASM bundle, no second compile target.
On paper it keeps the shared types and drops the 22-minute tax. He's explicit that it's a bet, not a result: early-stage, breaking changes expected, and he gives up the desktop and mobile targets. He promises a follow-up with real numbers.
That's the right way to make this argument. Not "framework X is better," but "here is my invoice, here is what I'm trying next, and here is what would change my mind."
What I take from it
A stack choice is a workflow choice, and the invoice arrives in CI. The costs are legible — minutes, memory, cache behaviour — while the benefits are diffuse: less context switching, safer refactors, boring production. Teams consistently underweight the diffuse benefits and overreact to the legible costs, which is why "just use TypeScript" and "just use Rust" are both argued with more confidence than the evidence supports.
The better question isn't "what helps me ship fastest," as Jung puts it. It's "what helps me keep shipping without hating my life." His answer is Rust on the backend, Dioxus for genuinely app-like frontends, and something lighter for dashboards — which is exactly why Topcoat is next. The interesting thing about his post is that he's willing to show the receipt.
Source: One year of Dioxus fullstack in production: the good, the painful — Hauke Jung, OXIDT.