The Next Hundred Rust GUIs: Practical Advice from Linebender

Linebender distills architecture, state, and rendering advice from real Rust GUI framework experience.
This article interprets Linebender's "Advice for the next 100 Rust GUIs." It highlights the tension between Rust's ownership model and dynamic UI state, recommending hybrid retained/immediate modes, centralized mutable state, and unidirectional data flow; GPU vector rendering via wgpu/Vello with optimized text batching and caching; and composing foundational libraries like winit, wgpu, and cosmic-text rather than reinventing the wheel. Compile times, debugging, and cross-platform consistency remain key pain points.
Rust's GUI ecosystem has long been a field full of debate and exploration. The Linebender team recently published an article titled "Advice for the next 100 Rust GUIs," offering valuable guidance to newcomers based on their hands-on experience building Rust GUI frameworks. The piece gained 201 points and 91 comments on Hacker News, showing that the community is highly attentive to practical paths for Rust GUI development.
Why Is Rust GUI Still Hard?
Rust's ownership model and borrow checker shine in systems programming, but they introduce extra complexity in UI development. UIs are inherently state-dense, event-driven, and highly dynamic, which creates tension with Rust's emphasis on static safety. Linebender's article starts from this tension and discusses how to design maintainable, extensible GUI architectures without violating Rust's core principles.
Although the original abstract provides limited information, community discussion and Linebender's past work (such as Druid and Vello) suggest that the article's core advice revolves around architecture choices, data flow management, and rendering pipelines.
Core Trade-offs in Architecture Design
Retained Mode vs. Immediate Mode
Rust GUI frameworks usually face a choice between two modes: retained mode, which builds a persistent component tree, and immediate mode, which rebuilds the UI every frame. Linebender's practice tends toward hybrid approaches, using Rust's type system to catch state errors at compile time while reducing runtime overhead through fine-grained reactive updates.
For developers, the key is understanding a framework's update semantics. If you choose retained mode, you need to carefully design data passing between components to avoid borrow conflicts; if you choose immediate mode, you need to pay attention to the performance cost of rebuilding every frame.
Retained mode and immediate mode are two fundamental architectural paradigms for GUI frameworks. Retained mode maintains a persistent UI component tree, where each component stores its own state and only updates the corresponding subtree when state changes; typical examples include Qt, GTK, and Flutter. Immediate mode regenerates the entire UI description from application state every frame, and the framework does not hold component state; examples include Dear ImGui and egui. Immediate-mode code is intuitive and state synchronization is simple, but rebuilding every frame incurs CPU overhead and makes fine-grained animation and focus management difficult; retained mode offers better performance and stronger control, but state synchronization and lifecycle management are complex. Rust's borrow checker is especially unfriendly to the persistent mutable trees of retained mode, so many Rust frameworks (such as iced and Druid) adopt a hybrid approach of message-driven design plus a virtual DOM, compromising between compile-time checking and runtime flexibility.
Expressing State Management in a Rusty Way
A common design pattern in Rust is to use message channels or unidirectional data flow to decouple UI from business logic. Linebender recommends centralizing mutable state in a few locations, passing data through immutable references, and using Rc<RefCell<>> or safer signal libraries (such as futures-signals) to manage cross-component state. However, overusing interior mutability weakens Rust's compile-time checking advantages, so a balance must be found between flexibility and safety.
Rc<RefCell<T>> is a common combination in Rust for shared mutable state: Rc provides multi-owner reference counting, and RefCell performs borrow checking at runtime, allowing internal values to be modified through immutable references. This pattern bypasses compile-time borrow checking at the cost of runtime panic risk and extra overhead. futures-signals offers a reactive alternative: a signal is an immutable value container, new signals are derived through combinators, changes propagate automatically, and manual subscription management is avoided. Compared with Rc<RefCell<>>, signal libraries make data flow explicit and reduce the risk of dangling updates and circular borrows, but they introduce asynchronous semantics and an additional abstraction layer. The choice requires trade-offs: Rc<RefCell<>> is sufficient for simple scenarios, while signals or unidirectional data flow are more maintainable for complex cross-component state.
Practical Advice on Rendering and Performance
Rust GUI rendering backends are diverse, ranging from traditional Skia bindings to pure Rust GPU renderers such as Vello. Linebender's rendering advice emphasizes prioritizing GPU-based vector rendering and leveraging modern graphics API abstraction layers such as wgpu to stay cross-platform and high-performance. For text and complex graphics, special attention must be paid to batching and caching strategies.
Another important point is event loop design. Avoid blocking operations on the rendering thread, use asynchronous tasks for I/O-intensive work, and trigger redraws through fine-grained event notifications.
wgpu is a cross-platform graphics abstraction layer in the Rust ecosystem based on the WebGPU standard. It can map to Vulkan, Metal, DirectX 12, and OpenGL (through backends), and can run in WebAssembly. Vello is a GPU-accelerated 2D vector renderer developed by Linebender. It implements path filling, stroking, and anti-aliasing based on wgpu and compute shaders, aiming to provide a high-performance vector graphics pipeline for Rust GUIs. Compared with traditional CPU rasterization (such as Skia's software backend), GPU vector rendering has clear advantages for complex graphics and high resolutions, but it requires handling GPU memory management, shader compilation, and driver compatibility. For text rendering, cosmic-text provides glyph layout, shaping, and caching, working with renderers such as Vello to complete the full pipeline from text to pixels.
Maturity of the Ecosystem and Toolchain
The Rust GUI ecosystem is still fragmented and lacks a unified solution like Qt or Electron. Linebender's advice is: do not try to reinvent the wheel from scratch; instead, combine existing foundational libraries (such as winit for window management, wgpu for rendering, and cosmic-text for text layout) into your own framework. This allows you to leverage community results while maintaining architectural flexibility.
For application developers, when choosing a framework, pay attention to its activity, documentation quality, and community support. Frameworks with different positioning, such as egui, iced, and Slint, already exist, each with its own trade-offs. Linebender's work focuses more on low-level infrastructure, providing reusable components for higher-level frameworks.
Implications for the Future
The title "the next 100" implies that Rust GUI is still in an early stage and needs extensive practice to distill best patterns. In community discussions, many developers mentioned compile times, debugging experience, and cross-platform consistency as current major pain points. As Rust continues to invest in the GUI field, these issues are expected to improve gradually.
For teams preparing to enter Rust GUI development, Linebender's core advice can be summarized as: embrace composition rather than reinventing the wheel, use the type system to express state, prioritize GPU rendering on performance-critical paths, and actively participate in community building. This experience comes from real framework development journeys and offers strong reference value.
One-line Summary
Based on hands-on Rust GUI framework experience, Linebender summarizes architecture, state, and rendering advice for newcomers.
Paragraph Summary
This article interprets the core ideas of the Linebender team's "Advice for the next 100 Rust GUIs." The article notes the tension between Rust's ownership model and the dynamic state of UIs and recommends hybrid retained/immediate modes, centralized mutable state, and unidirectional data flow to balance safety and flexibility; at the rendering layer, prioritize GPU vector rendering such as wgpu/Vello and optimize text batching and caching; for ecosystem strategy, combine foundational libraries such as winit, wgpu, and cosmic-text rather than reinventing the wheel. Community discussion reflects that compile times, debugging experience, and cross-platform consistency remain major pain points, and Rust GUI is still early and needs extensive practice to distill best patterns.
Related articles

Hermes Agent's Self-Evolution Mechanism: Markdown Skills That Understand You Better Over Time
Explaining Hermes Agent's self-improvement mechanism: how Markdown skill files capture task experience, support manual or automatic storage, cross-task reuse, and feedback-based skill correction for an increasingly personalized experience.

Tamagotchi: Lessons from the Virtual Pet's Rise and Fall
A look back at the Tamagotchi's rise and fall, how its emotional design hooked users, and what it teaches today's AI companionship products.

Headphones as Stage: How Auracast Is Reshaping the Live Performance Experience
A New York SoHo Playhouse performance required audiences to wear Auracast-connected headphones. This article examines how Bluetooth broadcast audio is changing the sound experience and operating model of live performance.