Rust GUI: Advice for Toolkit Builders in 2026

The case for building a Rust GUI is getting stronger, and a new round of advice for toolkit authors says the next wave of projects should aim higher on performance. Roughly 20 Rust GUI toolkits have been announced in the 4.5 years since the last such guide, and interest has jumped again as AI-assisted rewrites push Rust into more codebases.

Many shipping apps run slowly, especially those built on cross-platform stacks. Platform vendors have largely stopped improving desktop toolkits and show little interest in the cross-platform problem, so Electron keeps gaining ground. With RAM still expensive and attention moving to mobile, that bloat costs real money.

Why Rust GUI adoption has been slow

Few flagship apps use Rust for the interface. The best-known example is the Zed editor, built on its own GPUI framework, which is also emerging as a pick for AI-driven rewrites, with Discord the biggest case.

GPUI fits Zed well, and shipping in a real product has lifted its credibility. But its 2D renderer is built around text editing and lacks full gradient support, blending and filters, which renderers in the class of Vello or Skia offer. It may not suit every general-purpose app.

The barriers may be fading. Rust is harder to write than TypeScript, Kotlin or Swift, and developers who know both Rust and UI are scarce. Yet there is evidence that an LLM’s cost of writing Rust isn’t much higher than for other languages, and in large codebases Rust may be easier to maintain because its type system enforces invariants. If every language costs about the same, the one with the best mix of safety and speed wins.

Native is a messier word on mobile

“Native” has no single meaning. Windows still lacks a clear native choice. On the Mac, developers split between AppKit and SwiftUI, which has known performance problems.

Mobile is different because platforms keep investing there. Details such as Liquid Glass on iOS come almost free with UIKit or SwiftUI, while apps built on cross-platform toolkits don’t quite look right. Gesture recognition, scroll dynamics and input method editors that match the platform exactly remain unsolved.

That makes a hybrid design attractive: native UI on top, shared business logic in Rust. Shopify recently chose this route after abandoning React Native. 1Password is believed to use the same architecture, and it is Discord’s “Phoenix” plan for mobile, with GPUI on desktop.

Fully Rust-based mobile UI is also advancing. An editor demo in the android-view project handles swiping, cursor movement by rolling the space bar and deleting in semantic chunks, plus composition regions needed for CJK input.

What is solved and what isn’t

Text layout was a major gap in 2022. It now has a good answer in Parley, backed by sustained investment from Google, Canva and Dioxus (now part of Cognition) plus community contributions. Most new Rust UI toolkits use it, and Cosmic Text is a viable alternative.

AccessKit has also matured into solid infrastructure used by most toolkits. A real integration differs from a box-ticking exercise, though. Rich text editing still isn’t fully accessible. That hits egui hardest, since it has to build and diff a tree every animation frame.

The system compositor remains the big open problem. Video makes it urgent: playback belongs in a hardware-accelerated layer, the only route to smooth frame rates on low-end devices. The subduction library is a start, but toolkits rarely integrate it. The ideal is a rich, high-level interface like Apple’s CALayer, with polyfills elsewhere. On Android, simple video overlays would use SurfaceFlinger layers and heavier compositing would run GPU shaders.

Immediate mode versus retained mode

One general-purpose toolkit may no longer be realistic now that LLMs can tune code for a specific use case. That shows up in the choice between immediate and retained mode.

Immediate mode means less code and looks simpler, which suits game development tools. The worry is scale: it handles the first 90% well and makes the second 90% harder. Production readiness needs stable widget identities for the accessibility tree and reliable caching of expensive results such as text layouts.

That is why the ArtCraft projects’ choice of egui draws skepticism. egui is a strong immediate-mode implementation and handles accessibility, which mainline Iced doesn’t yet, but it wouldn’t be the first pick for productivity or design applications.

Separate design from execution

LLM-assisted engineering works best with clearly scoped modules and solid specs. Given clear goals such as speed and resistance to bad inputs, a model does well inside a module.

That clashes with how toolkits are usually chosen, by how good they look. Apple’s frameworks carry a lot of design knowledge in their defaults. The proposal is to split design from execution, with a good spec between them. Web standards, backed by the extensive WPT test suite, are a sensible base but shouldn’t be followed slavishly: the DOM is slow and memory-hungry, full CSS resolution is expensive, and the web has no solid way to represent virtualized lists.

The Blitz browser engine suits hybrid approaches: it could start with Stylo for CSS selectors and swap in a leaner engine later. Xilem and Masonry show the modular idea in practice. The reactive layer is independent of the elements it controls, and Masonry is independent of the layer above it. SwiftUI bundles widgets, reactivity and language together.

Where performance can still improve

Optimized Rust will already beat almost any shipping GUI. The open question is whether smooth UI is possible even on low-end Android phones. Precomputing the static parts of a design helps. So does using layers well, since they avoid re-rendering unchanged regions. Too many layers cost RAM, so toolkits rely on heuristics or hints such as SwiftUI’s .drawingGroup() and Flutter’s RepaintBoundary.

What toolkit builders should do next

The advice is to be bold, build on solid foundations, use well-defined specs and work with open source upstream without sending maintainers low-quality pull requests. A system compositor library, built as a quality community project, is the clearest gap. Expect a small explosion of experiments in Rust GUI.

Source: Linebender

Written by

Saksham Bhargava

Saksham Bhargava runs Alteroid and has been writing about consumer technology for over five years, covering iPhone, Android, Windows, AI tools and gaming. With an MCA and six years of hands-on web development experience, he tests the features he writes about on his own devices and focuses on clear, practical guides that solve real problems. Away from the screen, he enjoys travelling to places most tourists skip.