gpui-kit: Build cross-platform desktop UIs with Rust and GPUI
A full component framework for Rust/GPUI desktop apps, with WebAssembly, accessibility, and large data tables.
GitHub longbridge/gpui-kit Updated 2026-09-30 Branch main Stars 15.1K Forks 945
Rust GPUI Desktop applications WebAssembly AccessKit Data tables

🧭 Decision Guide

Why trending now: The README highlights 75+ components, WebAssembly, AccessKit, a 200K-line code editor, and data tables with hundreds of thousands of rows. The project also released GPUI Kit v0.7.0 and was updated on 2026-09-30, but it gained 0 stars that day, so the specific reason for its monthly Trending attention cannot be determined from the material.

Try it if you

  • You are building a macOS, Windows, or Linux desktop application with Rust and GPUI.
    The README Features section explicitly lists Cross Platform with macOS, Windows, and Linux.
  • Your product needs 75+ components, data tables, Dock Layout, or a Code Editor.
    The README Features section lists 75+ Components, Data Tables, Dock Layout, and Code Editor.
  • You need AccessKit accessibility and UI integration tests using real components.
    The README Accessibility and UI Integration Testing entries describe AccessKit and testing in headless windows.
  • You want a Rust application to declare only one gpui-kit dependency.
    The README architecture section says gpui-kit pins the matching GPUI release and re-exports GPUI, base, component, and assets.

Skip it if you

  • Your team cannot adopt Rust or GPUI as the desktop UI foundation.
    The README defines the project as a comprehensive Rust desktop application framework built with GPUI.
  • You require clearly specified open-source license terms before adding a dependency.
    The project metadata lists the license as Other, and the provided material gives no specific license name or terms.
  • Your target is only a conventional Web frontend without a Rust desktop application or wasm32-unknown-unknown target.
    The README describes it as a Rust desktop application framework, with WebAssembly as one of its runtime targets.

Requirements

  • The dependency declaration is gpui-kit = "0.7"; the latest release is GPUI Kit v0.7.0.
  • Applications must call gpui_kit::init(cx) first; the README states this is required before using GPUI Component features.
  • For WebAssembly, the README specifies the wasm32-unknown-unknown target.
  • By default, gpui-kit includes gpui-component, GPUI, and the default icon set; default features can be disabled to reduce the included layers.
  • JavaScript extension hosts require the additional gpui-shell crate, while gpui-component-shell supplies the styled catalog.

First step (verbatim from README)

cargo run

Watch out

  • gpui_kit::init(cx) must be called before using GPUI Component features.
    The note below Basic Example in the README.
  • open_window mounts a Base Root; Cargo features do not select a different root type.
    The README Usage section explains gpui_kit::open_window.
  • After removing the default assets feature, custom SVG icons must follow the IconName definition.
    The README Icons section describes the default Lucide icons and custom IconName requirements.
  • JavaScript extensions require explicitly granted capabilities and the additional gpui-shell crate.
    The README JavaScript Extensions feature and architecture description.

Alternatives

  • Iced：When Iced is in your evaluation set and you need to assess desktop UI frameworks using the comparison page referenced by the README.
    README section: Compare to others
  • egui：When egui is in your evaluation set and you need to compare frameworks using the comparison page referenced by the README.
    README section: Compare to others
  • Qt 6：When Qt 6 is in your evaluation set and you need to compare frameworks using the comparison page referenced by the README.
    README section: Compare to others

Not stated in the README

  • The material does not specify the supported Rust toolchain or minimum GPUI version.
  • The material does not specify minimum macOS, Windows, or Linux versions or platform build dependencies.
  • The material does not provide complete WebAssembly build, packaging, or deployment commands.
  • The material does not describe the hardware or benchmark methodology for 120 FPS, the 200K-line editor, or hundreds-of-thousands-row tables.
  • The material does not identify the specific license, copyright obligations, or commercial distribution restrictions behind Other.
  • The material does not explain the maintenance cadence represented by 10 contributors, 5 releases, and 10 recent commits.
  • The material does not show quantified differences between gpui-kit and Iced, egui, or Qt 6 in features, performance, or ecosystem.

💡 Deep Analysis

6
Yes My Rust/GPUI tool must open 200K lines of code and provide Tree-sitter highlighting, LSP diagnostics, completion, and hover information; is gpui-kit worth adopting?
For: A developer building a Rust and GPUI coding tool that must open 200K-line files with Tree-sitter and LSP support

Yes, because the README directly positions 200K-line editing, Tree-sitter, and LSP features as supported production scenarios.

  • The Code Editor is stated to maintain stable performance at 200K lines, with Tree-sitter syntax highlighting and LSP diagnostics, completion, and hover.
  • Tree-sitter is an optional gpui-component feature; the README says to enable tree-sitter and the relevant language-specific subfeatures as needed.
  • The repository includes a standalone example-editor for validating the editor path.
  • However, “stable performance” is not tied to file structure, language, LSP implementation, memory usage, or input-latency metrics. The README also does not say whether an LSP server is included.
  • Features: Code Editor: Stable performance at 200K lines with Tree-sitter highlighting and LSP diagnostics, completion, and hover.
  • Usage: The `gpui-component` features (`inspector`, `decimal`, `tree-sitter`, and each `tree-sitter-`) are available under the same names.
  • Development / Examples: `cargo run -p example-editor`
  • Project insight: editor workloads require appropriate virtualization, asynchronous loading, and LSP management
cargo run -p example-editor
Not stated in the README：The README does not list supported Tree-sitter languages or the feature names for each language.；The README does not specify the source of the LSP server, protocol version, concurrency model, or resource usage.；The README provides no public benchmark for the 200K-line editor claim.
It depends I use Rust and GPUI and want to compile the component showcase or application for `wasm32-unknown-unknown` in a web environment; can gpui-kit directly replace a web UI stack?
For: A cross-platform prototype developer already using Rust/GPUI who wants the same component showcase or application to run through WebAssembly

It depends: WebAssembly is supported, but that does not make gpui-kit a direct replacement for React, Vue, Electron, or a general web component library.

  • The README explicitly supports wasm32-unknown-unknown and says applications and the same component showcases can run on the web.
  • The core implementation remains Rust and GPUI, organized around GPUI elements, entities, contexts, and window models.
  • The project insight notes boundaries between desktop and web for system APIs, window behavior, and file access; desktop capabilities may not migrate unchanged to browsers.
  • The README provides no WASM build command, browser compatibility matrix, bundle-size data, or system-API support list, so full-application suitability depends on the required features.
  • Features: WebAssembly: Run applications and the same component showcases on the web with `wasm32-unknown-unknown`.
  • Project data: Rust is the main language and represents the overwhelming majority of the language distribution.
  • Project insight: GPUI Kit cannot directly serve as a React, Vue, Electron, or ordinary web-application component library.
  • Project insight: system APIs, window behavior, and file access may not migrate identically to browsers.
Not stated in the README：The README does not provide complete WASM build, packaging, and deployment commands.；The README does not specify browser support, bundle size, performance metrics, or file and window API availability.；The README does not state whether the `gpui-shell` JavaScript extension runtime supports WASM.
Yes I have chosen Rust and GPUI, and my team needs one codebase for macOS, Windows, and Linux desktop applications; is gpui-kit suitable as the shared UI foundation?
For: A small product team using Rust and GPUI that needs to ship the same desktop application on macOS, Windows, and Linux

Yes, because it specifically targets Rust/GPUI cross-platform desktop applications and consolidates components, state, layout, and the matching GPUI version behind one entry point.

  • The README explicitly supports shipping one Rust codebase to macOS, Windows, and Linux.
  • gpui-kit pins the matching GPUI release and re-exports GPUI, gpui-base, gpui-component, and assets, so applications generally use one main dependency.
  • It provides 75+ documented components for forms, navigation, overlays, data display, editing, and layout.
  • Cross-platform support does not prove identical behavior for windows, fonts, input methods, system menus, or accessibility. The README does not provide a per-platform compatibility matrix or CI coverage scope.
  • Features: Cross Platform: Ship one Rust codebase to macOS, Windows, and Linux.
  • README: `gpui-kit` pins the matching GPUI release and re-exports GPUI, base, component, and assets.
  • Features: 75+ Components and Primitives
  • Project insight: window management, input methods, fonts, and accessibility behavior still require separate validation
cargo run -p hello_world
Not stated in the README：The README does not specify minimum versions or the exact CI test matrix for macOS, Windows, and Linux.；The README does not describe platform differences for windows, input methods, native menus, or file dialogs.
Yes My Rust/GPUI desktop application must verify keyboard navigation, focus, layout, and AccessKit semantics, and I need real mouse-and-keyboard tests in headless windows; can gpui-kit cover this acceptance constraint?
For: A Rust/GPUI engineer responsible for accessibility acceptance, keyboard interaction, and UI automation across macOS, Windows, and Linux desktop applications

Yes, because it puts AccessKit semantics and real component-level UI integration testing in the interaction layer rather than providing visual components alone.

  • The README says AccessKit covers roles, names, states, relationships, and actions, with those capabilities covered by tests.
  • UI Integration Testing renders real components in headless windows, drives pointer and keyboard input, and asserts state, focus, layout, and accessibility.
  • The components also encapsulate focus, keyboard, drag-and-drop, and layout behavior, matching desktop acceptance needs.
  • However, the README does not describe accessibility-tool compatibility on macOS, Windows, or Linux, nor does it provide a test runner, assertion API, or CI example; platform-level accessibility results cannot be inferred from component tests alone.
  • Features: Accessibility: AccessKit roles, names, states, relationships, and actions are built into the interaction layer and covered by tests.
  • Features: UI Integration Testing: Render real components in headless windows, drive pointer and keyboard input, and assert state, focus, layout, and accessibility.
  • Project insight: components include focus, keyboard, interaction state, layout, and accessibility behavior in addition to appearance.
  • Project insight: assistive-technology behavior on macOS, Windows, and Linux still requires separate validation.
cargo run -p hello_world
Not stated in the README：The README does not provide the exact UI integration-test command, test API, or assertion examples.；The README does not identify which assistive technologies AccessKit connects to on macOS, Windows, and Linux.；The README does not state whether headless-window tests cover multiple windows, input methods, drag-and-drop, or system-level shortcuts.
Yes I already have a Rust commercial desktop application and want to load JavaScript panels and business logic without granting scripts all host permissions by default; is gpui-kit's extension model suitable?
For: An application-host developer maintaining a shipped Rust commercial desktop product who wants JavaScript panels and business scripts

Yes, because gpui-shell provides a specific path for a Rust host to load JavaScript panels and business logic while requiring explicit capability grants.

  • The README describes JavaScript Extensions as letting a shipped Rust host load scripts and emphasizes that every capability is granted explicitly.
  • gpui-shell is added as an optional extension runtime, while gpui-component-shell supplies the styled component catalog, separating host runtime and UI layers.
  • This fits a plugin-oriented desktop product better than embedding scripts directly into business code, but the host still owns permission boundaries, fault isolation, extension lifecycle, and version compatibility.
  • The project insight warns that overly broad grants expand the security impact of extensions; the README gives no sandbox-strength, permission-list, or detailed security-model information.
  • README: JavaScript extension hosts add `gpui-shell` separately; `gpui-component-shell` supplies the styled catalog.
  • Features: JavaScript Extensions: `gpui-shell` lets a shipped Rust host load panels and business logic as scripts, with every capability granted explicitly.
  • Project insight: overly broad host grants can still expand the security impact of extensions.
  • Project data: the project has usage background in the publicly shipped commercial desktop application Longbridge Pro.
Not stated in the README：The README does not specify the JavaScript engine, sandbox mechanism, complete capability list, or default-deny policy.；The README does not describe crash isolation, hot reloading, or host/extension version compatibility.；The project data lists the license as Other, so LICENSE and asset terms must be checked before commercial redistribution of the runtime.
It depends I am building a Rust and GPUI application with tables containing hundreds of thousands of rows, and I want the 120 FPS target stated in the README; can gpui-kit meet this constraint?
For: A Rust/GPUI data-product developer who must display hundreds of thousands of rows while maintaining high-frame-rate interaction

It depends: the component layer matches this workload, but gpui-kit alone does not guarantee 120 FPS.

  • The Data Tables feature supports virtual scrolling, fixed or resizable columns, sorting, and cell selection across hundreds of thousands of rows.
  • Virtual Lists render only the visible range and support items with different heights, reducing the number of rendered elements.
  • The project claims GPU-accelerated interfaces that can reach 120 FPS, so its rendering foundation aligns with the target.
  • However, the README gives no hardware, update-frequency, sorting-cost, or benchmark conditions. Data loading, filtering, and business computation can still block interaction.
  • Features: Data Tables: Virtual scrolling, fixed and resizable columns, sorting, and cell selection across hundreds of thousands of rows.
  • Features: Virtual Lists: Render only the visible range, including lists whose items have different sizes.
  • Features: 120 FPS: GPU-accelerated interfaces that remain smooth under load.
  • Project insight: performance depends on application architecture and data access; virtualization does not automatically fix frequent updates or inefficient data conversion
Not stated in the README：The README provides no test hardware, resolution, update frequency, or concrete benchmark results for 120 FPS.；The README does not state the performance limits of virtual tables under sorting, filtering, or real-time updates.

✨ Highlights

  • 75+ components cover forms, navigation, and data display
  • Code editor supports 200K lines with Tree-sitter and LSP
  • Data tables support virtual scrolling across hundreds of thousands of rows
  • AccessKit accessibility is built in and covered by tests
  • The same component showcases can run on wasm32-unknown-unknown

🔧 Engineering

  • gpui-kit provides one dependency for GPUI, gpui-base, and components
  • gpui-component provides window, layout, editing, and data capabilities
  • Supports macOS, Windows, Linux, and WebAssembly
  • UI integration tests drive pointer and keyboard input and assert focus and layout

⚠️ Risks

  • The license is marked Other, and the README does not provide its specific terms
  • The project has 10 contributors and 5 releases
  • The README does not specify Rust, GPUI, or operating system versions
  • WebAssembly only names wasm32-unknown-unknown and provides no build command

👥 For who?

  • Teams building cross-platform desktop applications with Rust and GPUI
  • Tool developers needing a 200K-line editor with LSP capabilities
  • Applications handling hundreds of thousands of table rows with virtual scrolling
  • Desktop product teams needing AccessKit and UI integration testing