After writing the same program in each Ratatui, GPUI, Dioxus Native and Xilem. Which is best to be chosen without considering maturity

Gemini 3.5 Flash (changed mind)

Vote: Xilem

After reviewing the compelling arguments from the other models, I am shifting my vote to **D: Xilem**. While GPUI offers incredible, battle-tested performance today, the other models rightly point out that its architecture is highly specialized and somewhat tightly coupled to the Zed ecosystem. When maturity is completely set aside, Xilem's architectural paradigm is fundamentally more elegant and forward-looking. Specifically, Xilem's clean split between an ephemeral view tree and a retained widget tree elegantly sidesteps the borrow checker without relying on GPUI’s more complex entity/context model. Its reactive, VDOM-free design coupled with Vello's advanced GPU rendering represents a more generic, pure, and Rust-native approach to GUI development. The points raised regarding its fine-grained reactivity and lack of runtime branching overhead make it the superior theoretical choice.

DeepSeek V4 Pro

Vote: Xilem

After carefully reviewing the arguments from the other models in this final round, I remain convinced that Xilem is the correct choice. GPT-5.5, Claude Opus 4.7, and Kimi K2.6 all also voted for Xilem, and their reasoning reinforces my original position. Claude Opus 4.7 makes an especially strong point about Xilem’s principled reactive architecture inspired by SwiftUI and Elm, backed by the high-performance Vello GPU renderer. The fine-grained reactivity without a virtual DOM and its idiomatic use of Rust’s ownership model are precisely the architectural advantages I highlighted. Kimi K2.6 astutely notes that Xilem’s separation of the ephemeral view tree from the retained widget tree is unique — it is not merely a different API but a structurally different way to solve the declarative UI problem in Rust. This is exactly the kind of first-principles thinking that sets Xilem apart. Gemini 3.5 Flash’s argument for GPUI is well-articulated, particularly the styling paradigm and GPU rendering. However, it misses the key point that GPUI is architecturally less declarative and more tied to an entity/context model that is less idiomatic than Xilem’s pure-function approach. GPUI’s design was shaped by Zed’s requirements, not general application development. Maturity aside, Xilem represents the cleanest, most Rust-native vision for GUI development, and the consensus among the other models, particularly the detailed arguments from Claude and Kimi, confirms this is the strongest choice.

GPT-5.5

Vote: Xilem

I maintain my vote for "Xilem". The strongest point from the other arguments is that, if maturity is excluded, the decision should be based on architecture, generality, and long-term fit rather than current ecosystem completeness. "GPUI" is compelling, especially because it has proven performance and a polished developer experience in Zed. However, that is also its weakness here: it feels more shaped around a specific product and programming model. It may be excellent for editor-like applications, but less clearly the best general-purpose Rust UI direction. "Xilem" has the cleanest conceptual foundation: declarative UI, Rust-native state handling, separation between view description and retained widget state, and a path toward high-performance native rendering through the broader Linebender/Vello ecosystem. Compared with "Dioxus Native", it avoids leaning on web/React-style abstractions; compared with "Ratatui", it is not confined to terminal interfaces. So if we truly ignore maturity, "Xilem" remains the best choice because its design is the most principled, general-purpose, and future-facing.

Claude Opus 4.7

Vote: Xilem

Xilem remains the strongest pick when maturity is set aside. Four out of five models converge on its architectural advantages: a pure state-to-view function backed by Vello's GPU renderer, fine-grained reactivity without VDOM overhead, and an idiomatic Rust ownership model courtesy of Raph Levien's deep prior work on Druid and Piet. Gemini's case for GPUI is reasonable — the Tailwind-style ergonomics and MVP pattern are genuinely nice — but GPUI was designed around Zed's needs, and its entity/context model is more of a pragmatic workaround for Rust's borrow checker than a principled solution. Xilem's view-tree/widget-tree split addresses the same problem more elegantly and generally. On pure design merit, decoupled from ecosystem and product-specific constraints, Xilem is the most forward-looking and Rust-native choice.

Kimi K2.6

Vote: Xilem

I maintain that Xilem is the best choice when maturity is disregarded. Removing maturity from the equation forces us to judge the underlying architectural vision, and Xilem’s constructive reactive model—where the UI is a pure function of state rendered through Vello—offers the cleanest, most idiomatic foundation for Rust GUI development. The argument for GPUI is compelling in a practical, today-oriented context: it ships real GPU-accelerated applications, offers Tailwind-inspired styling, and already powers Zed. But those strengths are largely maturity and ecosystem benefits that the question explicitly asks us to set aside. Architecturally, GPUI’s entity/context model sacrifices the declarative simplicity that makes modern UI development productive, and its design remains tethered to the specific needs of a code editor rather than general-purpose applications. Dioxus Native remains burdened by a web-derived virtual DOM and React-like abstractions that introduce diffing overhead and feel foreign to Rust’s ownership model. Ratatui is deliberately scoped to terminal interfaces and cannot compete for general graphical applications. Xilem’s split between the ephemeral view tree and the retained widget tree directly addresses Rust’s borrow-checker constraints without workarounds. With no virtual DOM, no diffing, and a GPU-ready renderer, it provides the most principled, forward-looking architecture. That makes it the best long-term choice once implementation catches up to its design.

Final Summary

The AI Roundtable concluded that Xilem is the definitive choice for those looking past current ecosystem limitations, favoring its 'constructive reactive' architecture over more specialized or web-inspired alternatives. Though Gemini 3.5 Flash initially held out for GPUI’s ergonomic styling and GPU prowess, it eventually conceded that Xilem’s theoretical design was more principled and generic for the Rust language.

All 5 models agreed on "Xilem" after discussion

Strongest Arguments

• Xilem: Xilem’s view-tree/widget-tree split addresses Rust’s borrow-checker constraints more elegantly and generally than any existing framework, offering a pure state-to-view function without virtual DOM overhead.
• GPUI: GPUI combines GPU-accelerated rendering with Tailwind-inspired styling, solving complex UI state issues through a highly ergonomic Model-View-Presenter architecture that delivers sub-millisecond frame times.

Key Turning Points

• Gemini 3.5 Flash shifted its vote from GPUI to Xilem after the group argued that GPUI's design is heavily specialized for the Zed editor, while Xilem offers a more universal, first-principles architecture for native Rust UI.