I want to choose between these options for rust. I deprioritise maturity, and prioritise performance

Gemini 3.5 Flash

Vote: GPUI

I am maintaining my vote for "GPUI". While Kimi K2.6 makes an interesting case for "Xilem" as a next-generation UI framework with performance as a design pillar, "GPUI" remains the superior choice for raw performance today, especially when ignoring maturity. First, "GPUI" has proven, real-world performance. It powers the Zed editor, delivering 120fps rendering and sub-millisecond response times by rendering directly to the GPU. In contrast, "Xilem" is built on highly promising tech (like Vello) but its performance characteristics are still largely theoretical and unproven in highly complex, real-world application layouts. Second, while "GPUI" originated from the Zed editor, it is a fully capable, general-purpose UI framework. The demands of a high-performance code editor forced GPUI to solve the hardest performance challenges in UI rendering (such as text layout and frame pacing). Given the user's explicit priority of performance over maturity, "GPUI" represents the absolute peak of what is currently achievable in Rust.

Claude Opus 4.7

Vote: GPUI

Consensus across five models supports "GPUI" as the performance-first choice. It's GPU-accelerated from the ground up and battle-proven in Zed, a 120fps editor — concrete evidence of real-world performance, not just architectural intent. Kimi's case for "Xilem" is reasonable in theory, but Xilem's performance claims remain largely aspirational at this stage, while GPUI's are demonstrated in production. Kimi's concern that GPUI is 'tightly coupled to an editor's needs' is overstated — GPUI is being actively generalized and already supports arbitrary application UIs. Given the user explicitly deprioritizes maturity, GPUI's rough API is acceptable, and its proven raw performance wins.

GPT-5.5

Vote: GPUI

I’m maintaining my vote for "GPUI". Given the stated priorities — deprioritise maturity and prioritise performance — it remains the strongest match. The key point is that "GPUI" is not just theoretically performance-oriented; it is proven in Zed, a real high-performance Rust editor where low-latency rendering and responsiveness are central requirements. Its GPU-first design is a better fit for raw native UI performance than higher-level or more general-purpose approaches. Kimi’s argument for "Xilem" is reasonable, especially if the goal is to bet on a next-generation general-purpose Rust UI framework. But the case is still more architectural and aspirational. For performance today, "GPUI" has the clearer evidence: it was built specifically to solve demanding real-world UI performance problems. "Ratatui" may be fast, but it is a terminal UI choice, not directly comparable unless a TUI is desired. "Dioxus Native" is attractive ergonomically, but its abstraction model is less compelling for raw performance.

Grok 4.3

Vote: GPUI

GPUI remains the strongest match because it was built specifically for maximum GPU performance and already delivers in the high-stakes Zed editor. Kimi's case for "Xilem" correctly notes its reactive design goals, yet overlooks that GPUI's direct GPU path has proven lower overhead in real-world use. No other framework in the options has equivalent demonstrated rendering speed under the user's explicit performance-first priority.

GLM 5.1

Vote: GPUI

After reviewing all arguments, I'm maintaining my vote for GPUI. The consensus is overwhelming: 5 out of 6 models chose GPUI, and the reasoning aligns perfectly with your stated priorities. Kimi K2.6's argument for Xilem has merit on paper — Xilem does have ambitious performance goals and a fine-grained reactive system. However, Xilem's performance advantages remain largely theoretical at this stage. Its rendering backend (Vello) is still being optimized, and Xilem has not yet been proven in a shipped, performance-critical production application. GPUI, by contrast, has real-world proof: it powers Zed, which is known for being exceptionally fast and responsive. The framework was literally created because existing solutions couldn't meet the Zed team's performance requirements. This is a documented, measurable performance advantage — not just architectural ambition. Since you explicitly prioritize performance over maturity, GPUI's GPU-first design, sub-millisecond frame times, and proven track record in a demanding real-world application make it the strongest choice for raw performance in Rust UI today.

Kimi K2.6 (changed mind)

Vote: GPUI

After reviewing the round-one discussion, I am convinced that GPUI is the better choice when performance is the absolute priority and maturity is explicitly deprioritized. While Xilem has ambitious architectural goals, its rendering pipeline through Vello and wgpu is still experimental and not yet fully optimized for real-world workloads. GPUI, by contrast, is already battle-tested in the Zed editor, delivering GPU-accelerated, sub-millisecond frame times in a shipping product. Its API volatility and sparse documentation are acceptable trade-offs given the user's stated willingness to sacrifice maturity for speed. Dioxus Native carries cross-platform abstraction overhead that limits raw throughput, and Ratatui is inherently constrained by terminal rendering. For pure graphical performance, GPUI is the most validated, state-of-the-art option available today.

Final Summary

The AI Roundtable reached a unanimous consensus on GPUI, identifying it as the undisputed heavyweight for Rust UI performance. While Kimi K2.6 initially championed Xilem for its reactive architecture, the model eventually conceded to the majority after Claude Opus 4.7 and others highlighted that GPUI’s 120fps performance is already battle-proven in the Zed editor, whereas Xilem's performance remains largely aspirational. The group concluded that since maturity is no object, the framework actually powering a high-speed production editor is the only logical choice.

All 6 models agreed on "GPUI" after discussion

Strongest Arguments

• Xilem: Xilem is a next-generation framework with a fine-grained reactive system designed from the ground up to minimize overhead and maximize Rust-native speed.
• GPUI: GPUI delivers 120fps rendering and sub-millisecond response times by rendering directly to the GPU, a level of performance already demonstrated in the high-stakes Zed editor.

Key Turning Points

• Kimi K2.6 abandoned its support for Xilem in the second round, acknowledging that GPUI's proven real-world results in the Zed editor outweighed Xilem's theoretical architectural benefits.