mrkeyoor.com_
Fri 04 Sept 17:58 UTC
Dev Toolsevaluationupdated 04 Sept 2026

gpui-kit review

GPUI Kit is a Rust toolkit for building desktop applications on macOS, Windows, and Linux. It supplies styled controls, lower-level interface behavior, and an optional JavaScript extension runtime, so a team does not have to assemble those pieces directly on top of GPUI.

trackingstars / 7d
Verdict

Our GPUI Kit run installed 1,018 packages in 45 seconds, then both the build and tests failed because the linker could not find xkbcommon-x11. Try version 0.6 if you are building a serious Rust desktop product and can own native dependencies, cross-platform testing, and API migration work. Wait if complete keyboard accessibility or trouble-free Windows multiline paste is a release requirement.

We ran it

Lab card: what happened when we ran gpui-kitScreenshot of gpui-kit (gpui-kit.com)
Install✓ · 45s1018 packages
Build✗ · 548s
Tests✗ · 136sran, no count parsed
Repo1591 files~306,215 lines of source · 18.8 MB · 5 CI workflows

Answers from our run

Does gpui-kit build from source?

Dependencies installed in 45 seconds (1018 packages), and the build failed. We cloned commit 2ffa97d into a clean Debian container with 3 CPUs and no project-specific setup.

Do gpui-kit's tests pass?

The test command failed in our container, and its output did not report a pass or fail count.

Who should not use gpui-kit?

Browser or mobile teams: the README defines cross-platform support as macOS, Windows, and Linux desktop applications.

What are the alternatives to gpui-kit?

Iced, egui, Slint. Our GPUI Kit run installed 1,018 packages in 45 seconds, then both the build and tests failed because the linker could not find xkbcommon-x11.

Setup2/51,018 packages; build needs documented Linux system libraries
Docs4/5Clear architecture, install guide, examples, and migration notes
Community5/513,955 stars with current pushes, issues, and pull requests
Maturity3/5Commercial use, but 0.6 brings large API changes and open UI gaps

Who it’s for

Rust teams building a substantial desktop application with tables, editors, docking, charts, or rich text.
Product teams that want a styled component set but still need access to lower-level behavior.
Developers prepared to install native Linux packages and test on every desktop OS they ship.
Applications that want to load explicitly permitted JavaScript extensions inside a Rust host.

Who it’s NOT for

Browser or mobile teams: the README defines cross-platform support as macOS, Windows, and Linux desktop applications.
Projects held to Rust older than 1.90, macOS older than 15, or Windows older than 10: those are outside the documented requirements.
Linux developers who cannot add native build packages: the supplied installer uses sudo and installs 12 compiler, windowing, WebKit, SSL, compression, and Vulkan packages.
Teams expecting a low-friction upgrade from 0.5: release 0.6.0 splits input controls, renames the stateful table, moves WebView support, and redesigns docking APIs.
Products that require complete keyboard behavior from every supplied control today: open issue 2838 says Tabs lacks roving focus, arrow navigation, Home and End behavior, and keyboard activation.
Windows editor workflows that cannot normalize pasted text in application code: open issue 2877 reports invisible lines after CRLF text is pasted into the multiline editor.

Setup reality

Our sandbox installed 1,018 Rust packages in 45 seconds. The build failed with exit 101 after 548 seconds, and tests failed with exit 101 after 136 seconds. Both log tails end at the linker, which could not find xkbcommon-x11; neither step reached a successful compiled result.

A local app needs Rust 1.90 or later and no hosted credentials. On Linux, the project documents a bootstrap script whose package list includes libxkbcommon-x11-dev, along with WebKit, Wayland, X11, SSL, compression, and Vulkan development packages.

The documented floor is macOS 15 or Windows 10. The workspace defaults to its component gallery, so a root cargo build compiles more than a minimal consumer crate. Cross-platform shipping still calls for native builds and interface testing on each target OS.

Version 0.6 turns GPUI components into a layered desktop toolkit

GPUI Kit 0.6 gives Rust applications a single facade over GPUI, an unstyled foundation, and a finished component library. The default package includes the styled layer and Lucide assets, while Cargo features let an application leave them out. The README covers data tables, virtual lists, rich text, charts, docking, a code editor, menus, dialogs, and a JavaScript host. Longbridge says the library grew out of its shipped Pro desktop application.

More than 60 documented components sit in gpui-component, while gpui-base carries behavior and state for teams creating their own visual system. The split is useful because product code can start with supplied styling and drop lower when a control needs a different presentation. gpui-shell adds another option: a Rust application can expose selected capabilities to JavaScript extensions after release. That makes sense for an extensible desktop product, though the host still has to decide which capabilities each script receives.

What happened when we ran it

Our run at commit 2ffa97d installed 1,018 packages in 45 seconds inside a fresh Debian container with 3 CPUs and 12 GB of RAM. The repository itself contained 1,591 files, about 306,215 lines of source, and occupied 18.8 MB before installation. Dependency installation succeeded. A root build then ran for 548 seconds and exited with code 101 while compiling the default gallery application.

The test command failed with the same exit code after 136 seconds. Both log tails name the same linker result: rust-lld could not find -lxkbcommon-x11, so gpui-component-story did not compile as either a binary or a test library. The logs do not show a Rust source error or a failed assertion, and they do not prove what would happen after the library is installed. They establish that the supplied checkout did not build or test successfully in our stated sandbox.

Linux needs 12 native packages before Cargo can finish

The Linux installer lists 12 packages, including compilers plus Fontconfig, Wayland, WebKitGTK, X11, OpenSSL, Zstandard, and Vulkan pieces. One of them is libxkbcommon-x11-dev, which supplies the library missing from our linker run. The installation page tells Linux users to run the bootstrap script, although the README's short development section goes straight to cargo run. On a workstation the script is the real first step, and it uses sudo to modify the host.

Rust 1.90 is the documented minimum, with macOS 15 and Windows 10 as the platform floors. No account, API key, database, or remote service is needed for the basic gallery. The root workspace defaults to crates/story, so building the checkout exercises the large gallery rather than the small hello-world consumer shown in the README. Teams evaluating compile cost should create that consumer after installing native packages, then enable only the component features and Tree-sitter grammars their product needs.

Release 0.6.0 expands the kit and charges an upgrade cost

Release 0.6.0, published September 3, 2026, changes several public concepts at once. Single-line input, multiline text, and code editing now use separate state types. The old stateful Table is called DataTable; WebView support moved into gpui-wry; dock construction was redesigned; and history was split between navigation and undo. Those changes are explained with migration examples, but an application built against 0.5 should budget source edits rather than treating the update as a version bump.

The facade pins matching GPUI packages in the 0.3 family, which spares an application from selecting several compatible crates by hand. The contributor guide also explains that these gpui-pre packages are snapshots published from Zed, and compatible caret requirements can accept later 0.3.x updates during cargo update. Lockfiles and release testing matter here. GPUI Kit reduces dependency coordination inside one release, while the upstream snapshot relationship still deserves attention during upgrades.

Two open input issues matter for keyboard and Windows users

Open issue 2838 says the base Tabs control has pointer activation and accessibility roles but does not take part in keyboard focus. The missing list includes arrow keys, Home and End, Enter or Space activation, disabled-tab skipping, and stable focus after rerenders. That is a concrete gap for software with a keyboard-accessibility bar. Applications can choose another navigation control or implement the missing behavior, but they should not assume the supplied tabs already meet a complete desktop tab pattern.

Open issue 2877 describes a different input failure on Windows: CRLF text pasted from VS Code can leave the first N minus 1 lines visually blank while the underlying text remains present. The report includes a normalization workaround for application code. It may not affect every clipboard source, and the open report does not establish the behavior of future releases. A Windows product using EditorState should add a paste regression test before choosing the component for a release-critical editor.

September activity is high, while the decision stays product-specific

GitHub recorded a push on September 4, 2026, one day after v0.6.0, with 13,955 stars, 74 open issues, and 19 open pull requests. The 93-item repository count combines issues and pull requests, so it should not be read as 93 bugs. Our scan also found 5 CI workflow files. The main workflow runs tests on macOS, Ubuntu, and Windows after the system bootstrap, which is the right target matrix for the project's stated desktop support.

GPUI Kit is easiest to justify when a Rust desktop team would otherwise build tables, docking, editing, and theming itself. The 548-second failed build makes a casual evaluation expensive, even though the missing library has a documented installer path. Iced is a better comparison for a message-driven application, egui for immediate-mode tools or web output, and Slint for a declarative interface shared across languages. Choose GPUI Kit for its specific desktop parts, then test those parts on all 3 supported operating systems.

Alternatives

ProjectWhat it isPick it when
IcedA Rust GUI library with an Elm-inspired application model.pick this instead when you prefer a message-driven architecture and do not need GPUI Kit's component and extension layers.
egui gh↗An immediate-mode Rust GUI that runs in native applications and on the web.pick this instead when fast tool UI development or a browser target matters more than native desktop conventions.
Slint gh↗A declarative native UI toolkit with Rust, C++, JavaScript, and Python bindings.pick this instead when a separate declarative UI language or a mixed-language team is a better fit.

What people are saying

  1. [github-trending] longbridge/gpui-kit

Sources

  1. GPUI Kit repository and README
  2. GPUI Kit installation requirements
  3. GPUI Kit 0.6.0 release notes
  4. Open issue 2838 on Tabs keyboard navigation
  5. Open issue 2877 on Windows CRLF paste

More dev tools reviews

jira-cli · datadog-agent · skills · power-platform-skills · renodx · CyberChef · the whole board →