A Field Report for Rust Desktop App Frameworks

I’ve recently found myself digging into the state of desktop app development in Rust not as a thought experiment, but because I actually needed to ship something cross-platform and fast. And not some toy CLI or a backend service. I’m talking about real desktop UI: buttons, windows, styling, user interaction, the whole deal.

Naturally, I went down the rabbit hole. What I found was equal parts promising and frustrating.

Let’s get something out of the way first: if you’re hoping for a “best” framework in the sense of “just use X and don’t look back,” you’re not going to find that here. The landscape is fragmented. Each option feels like it was built with a different kind of developer in mind. That’s not necessarily a bad thing, but it means tradeoffs are baked into every path.

Tauri is the one that keeps coming up first, and for good reason. It’s probably the most mature of the bunch. You get to write your frontend in the same tech used on the web React, Svelte, Vue, whatever and power it with a Rust backend. It’s a familiar workflow if you’re coming from the web world. Tauri handles windowing, IPC, security, bundling. It feels like Electron done right. The catch? You still have to live in the JavaScript ecosystem, with all its glorious complexity. That means Node, npm, packages that break, and the usual dance. If you’re comfortable with that, Tauri works. But don’t expect a clean, minimal Rust-only project. One thing I did like about Tauri is its frontend framework is well documented and most of LLMs can help you with it pretty well, though its backend you havet to get your hands dirty with it and read the docs in detail.

Then there’s Dioxus. This one got my attention because it tries to do something different: give you a full-stack Rust experience, including the UI. It mimics React’s component model but in Rust, using a DSL called RSX that maps pretty cleanly to HTML. You can think of it as React + JSX but in a strongly typed, Rusty way. Sounds perfect, right?

Well, sort of. Dioxus is still webview-based on the desktop, which means it’s not really native rendering. Also, you don’t get access to the npm ecosystem. That means no ChakraUI, no Tailwind plugins, no community-built React components. You’re building everything yourself, or settling for simpler layouts and utility-class CSS. If your app’s UI is relatively basic, this might not bother you. But if you’re trying to make something beautiful or complex, you’ll hit walls quickly.

Native options exist too. Iced and egui are probably the two you’ll hear about the most. They render directly via WGPU or other backends, which means no browser, no Node, no web tech at all. It’s all Rust, and that’s satisfying in its own right. But with that purity comes a cost: UI work becomes slow, tedious, and sometimes creatively limiting. You’re not getting Material UI or Tailwind or any of the shortcuts you might be used to. Styling becomes verbose. Layouting can feel like a chore. It works, and it works well for simple tools or internal apps, but I wouldn’t want to build a consumer-facing app with them just yet.

One wildcard I explored was Slint. It positions itself like Qt but in Rust. They’ve got their own UI language and rendering engine. Performance is great, and you get a clean separation of logic and layout. It actually feels like what Flutter might be if you removed the Google overhead and swapped Dart for Rust. But Slint has some licensing quirks. Depending on your business model, you may or may not be comfortable with that. Worth checking before you commit.

So what did I end up choosing? For my use case a desktop utility with some visual polish and network IO I initially went with Dioxus. It seemed promising: clean, all Rust, and declarative. But I ran into headaches fast. The app I was building had a map-heavy interface, and trying to bring something like MapLibre GL into the frontend just wasn’t practical. There’s no straightforward way to integrate advanced JS libraries into Dioxus’s RSX-driven view layer, and it quickly became clear I was fighting the framework more than building my app.

I pivoted to Tauri. The switch wasn’t painless. The constant back-and-forth between the JavaScript frontend and Rust backend felt like context-switching hell at first but once I got the architecture right, it became much smoother, as I mentioned before, the frontend framework is well documented and most of LLMs can help you with it pretty well, which is a huge plus.

There’s no perfect stack today. You either write some JavaScript, or you settle for simpler UIs, or you wrestle with bundling and tooling. But if you’re willing to deal with the rough edges, Rust is already viable for desktop apps. And in a year or two, it might even be great.