/build-gpui-apps

Comparison

This guide compares cross-platform desktop UI frameworks and their documented ecosystems. Green means the capability is available, yellow means it needs more application work or validation, and red means it is not provided. These marks describe availability, not performance. Check the version, backend, platform, and license for your application.

Legend: <comparison-status value="yes" decorative></comparison-status> Yes · <comparison-status value="partial" decorative></comparison-status> Partial · <comparison-status value="no" decorative></comparison-status> No. Ecosystem packages count where noted below.

Component count. GPUI Kit documents 75+ components and primitives. The other numbers count entries in the linked Iced 0.14 widget module (35), egui 0.36 widgets module (16, including TextEdit), Qt Quick Control descendants (52), and Slint standard widgets catalog (24). These catalogs include different kinds of helpers and exclude different add-ons, so the counts show catalog scale rather than a strict ranking.

Documentation. GPUI Kit covers its current public surface with core guides, component documentation, API reference, and a live gallery. Experimental features are documented with their current limits.

Size provenance. The first four values preserve the original main branch's Hello World release estimates; its Qt footnote linked this binary-size study. Slint's ~21 MB comes from a Slint 1.18.1 Hello World built with cargo build --release on Linux x86-64 and stripped to 20,768,216 bytes (19.81 MiB). These are approximate references from different build conditions, not verified minimums or a same-method benchmark.

Frame rate. This table does not rank frame rates: no shared workload, hardware, or presentation measurement backs a cross-framework FPS figure. A 120 Hz target gives each frame roughly 8.3 ms across the relevant pipeline; it is not a claim that an idle window redraws continuously or that every complex screen sustains 120 displayed frames per second. See FPS Monitor for GPUI's draw and present measurements.

Decision guide

The capability matrix shows coverage; these trade-offs show when that coverage matters. They are judgments about the documented APIs, not benchmark results.

AI can edit GPUI Kit's Rust UI code directly; a drag-and-drop editor is unnecessary.

What the rows mean

Rendering model. GPUI Kit constructs an element description from current inputs during a render pass. It retains Entities, keyed element state, and optionally cached views. The label in the table describes both parts; it is not a promise to rebuild the entire UI on every display refresh. The rendering model explanation separates these layers. Iced describes a state/message/update/view architecture. egui calls itself immediate mode. Qt Quick retains its scene graph between frames, while Slint uses reactive property bindings.

Desktop basics. All five can open multiple desktop windows, handle keyboard shortcuts, and customize visual themes, though the APIs differ. For example, Iced exposes window opening, eframe supports native viewports, and Slint documents key bindings and widget styles. Test IME, clipboard, and drag-and-drop behavior on each target platform.

Rendering, themes, and CJK. The “Rendering stack” row names the framework or selectable graphics backends, not a common GPU benchmark: egui's eframe supports glow and wgpu, Qt Quick uses a scene graph over Qt RHI, and Slint lists FemtoVG, Skia, and software renderers. GPUI Kit's 38 theme choices are the 36 variants in this repository's themes/*.json plus Default Light and Dark; Iced 0.14 documents 22 preset variants plus Custom. The original table's “egui CJK: Bad” was too broad: egui requires a custom font for Asian characters, while Qt documents script-aware fallback. Font coverage still depends on the shipped or installed fonts.

Table column resizing. GPUI Kit, egui_extras, Qt, and Slint support it; Iced does not provide built-in drag resizing.

Large-table virtualization. This retains the original table's distinction between visible rows and visible columns: GPUI Kit's DataTable tracks both in its visible range; egui_extras TableBody::rows renders visible rows; and Qt Quick TableView reuses delegates as rows and columns leave the viewport. Iced's documented table API does not promise built-in virtualization. Slint's StandardTableView places its row repeater inside a ListView, which instantiates only visible rows. Its column and cell repeaters do not use the same viewport virtualization.

Editor and highlighting. GPUI Kit's Editor stores text in a Rope. It provides code-oriented behavior such as folding, diagnostics, completion, and hover. Syntax highlighting uses Tree-sitter when the matching grammar feature is enabled; large buffers are parsed in the background, and edits can reuse the previous parse tree. The editor's text model and highlighting engine are separate decisions: a Rope alone does not imply highlighted text. Iced's TextEditor has feature-gated highlighting, egui's TextEdit accepts a custom layouter and can use egui_extras syntax highlighting, while Qt provides QSyntaxHighlighter. This row describes an available API, not comparable performance at the same document size.

Text models. The table names each editor's storage or editing abstraction: GPUI Kit keeps text in a Rope; Iced uses COSMIC Text, egui accepts a TextBuffer, and Qt exposes QTextDocument. This describes an API shape, not a comparative speed result.

Formatted text. GPUI Kit TextView renders selectable Markdown and HTML; its Markdown parser also passes inline HTML nodes to its HTML parser. Iced's Markdown widget does not expose an HTML item; egui relies on add-ons for Markdown, and Qt's QTextEdit supports Markdown with only part of embedded HTML. “No” in this row means the documented built-in Markdown path does not handle inline HTML; an application can still add another renderer.

HTML rendering. TextView::html handles article content such as headings, paragraphs, links, images, lists, and tables. It is partial because it does not implement general CSS layout or run scripts; it is not a WebView. Qt's QTextDocument supports a broader HTML 4 and CSS subset, also without browser behavior. This row compares documented native HTML document rendering, so a separate WebView integration does not count. Iced, egui, and Slint do not provide an equivalent native document renderer in the compared APIs.

Tables and lists. “Advanced data table” means a component for large datasets with virtualized rendering, sorting, selection, and column management. GPUI Kit's DataTable includes these behaviors; sorting the underlying data is supplied by its delegate. Qt's QTableView and model/view system also cover this use case. egui_extras TableBuilder virtualizes rows and resizes columns, but leaves more data behavior to the app. Slint's StandardTableView exposes sorting callbacks and selection; Iced's Table provides a simpler starting point. Separately, GPUI Kit VirtualList, egui ScrollArea::show_rows, Qt ListView, and Slint ListView create visible list items on demand. Iced offers scrolling and visibility primitives, with virtualization left to the application.

Dense desktop UI. GPUI Kit includes VirtualList, DataTable, charts, TextView, and Dock. Iced has rich text, a table, a feature-gated Markdown widget, Canvas, and pane grids; assembling a virtualized table or chart remains application work. The egui ecosystem supplies third-party egui_commonmark for Markdown, egui_dock for docking, egui_extras tables and egui_plot. Qt provides model/view tables, dock widgets, QTextDocument, and the separately licensed Qt Graphs module. Slint provides StandardTableView and a ListView that instantiates visible items; its Path can draw custom graphics, but is not a ready-made chart.

Product readiness. GPUI Kit's Accessibility, Testing, I18n, and Animation guides describe the local implementation and its limits. Its components contain translations, while application strings and locale policy remain the application's responsibility. Iced's accessibility integration is still tracked as open work; its test harness is available. egui documents AccessKit and egui_kittest. Qt has mature accessibility, internationalization, and Qt Test facilities. Slint documents accessibility properties and translations; its testing backend is preliminary and belongs to an internal crate. A “Yes” in the accessibility row still requires testing with assistive technology on each target platform.

Platform reach. GPUI Kit has experimental iOS integration and working WebAssembly showcases; the latter have not been validated here as a full application distribution path. Iced has a web example, while native mobile support remains under discussion. eframe runs egui on web and native platforms, with Android/iOS integration to validate for each app. Qt documents its supported platforms and WebAssembly limits. Slint documents mobile and web targets; its web output is a canvas, without browser screen-reader support. None of these canvas-based Wasm paths should be treated as an HTML application by default.

WebView. GPUI Kit has an experimental Wry integration. Its native view covers GPUI elements in the same bounds, so use a separate window or popup when layering matters. The integration currently documents macOS and Windows; its Linux example is unfinished. Qt provides official WebEngine and WebView modules, though Qt WebView also limits overlapping QML items. This row counts integrations maintained for the compared framework version: Iced has a third-party iced_webview crate targeting Iced 0.13, but no verified integration here for current Iced 0.14; egui has no comparable maintained native WebView, and Slint's WebView request remains open. A red dot does not rule out an application-specific bridge.

Licensing and scope. GPUI Kit is Apache-2.0; Iced is MIT; egui is MIT or Apache-2.0; Qt uses commercial, LGPLv3, or GPLv3 terms by module, with Qt Graphs GPLv3 or commercial; Slint has GPLv3 and commercial or royalty-free terms. Native single-platform stacks such as SwiftUI and WinUI have a different platform scope. Electron and Tauri use a WebView/JavaScript UI architecture and deserve a separate evaluation rather than a score in this native UI matrix. Bundle size and frame rate depend on build features, renderers, fonts, packaging, and workload; measure a release build of the product you intend to distribute.

Documentation license: original prose and illustrations for which GPUI Kit holds licensing rights are also offered under CC BY 4.0. When copying or adapting, credit GPUI Kit, link the source (https://gpui-kit.com/docs/comparison) and https://creativecommons.org/licenses/by/4.0/, and indicate changes. Code examples and software source use Apache-2.0; third-party material retains its terms; existing Apache-2.0 permissions remain.

Bundled from GPUI Kit. Documentation prose: CC BY 4.0; code examples: Apache-2.0. Changes: documentation links localized, asset URLs made absolute, and this attribution added.