GPUI Kit

English | 简体中文

Build fantastic, high-performance desktop apps with Rust and GPUI.

GPUI Kit is a comprehensive Rust desktop application framework. It combines a production-ready UI system with application-grade data, layout, and editing capabilities, all built on a reusable foundation of behavior, state, and infrastructure. GPUI Kit ships 75+ documented components and primitives, WebAssembly support, AccessKit accessibility, UI integration testing, and an optional JavaScript extension runtime.

Documentation: https://gpui-kit.com

gpui-kit             The one crate applications depend on
├── gpui-base        Unstyled behavior, state, and infrastructure
└── gpui-component   GPUI Component: the complete styled UI system

gpui-kit pins the matching GPUI release and re-exports GPUI, base, component, and assets, so a Rust application lists a single dependency. JavaScript extension hosts add gpui-shell separately; its default components feature supplies the styled catalog.

See the executable application recipe and AI-assisted development acceptance checks for a tested starting point and verification commands.

Features

• 75+ Components and Primitives: Forms, navigation, overlays, data display, editing, feedback, and layout, with polished interactions and productive defaults.
• Production Ready: Used to build Longbridge Pro from day one and continuously refined in a publicly shipped commercial desktop application.
• WebAssembly: Run applications and the same component showcases on the web with wasm32-unknown-unknown.
• Accessibility: AccessKit roles, names, states, relationships, and actions are built into the interaction layer and covered by tests.
• UI Integration Testing: Render real components in headless windows, drive pointer and keyboard input, and assert state, focus, layout, and accessibility.
• Native Feel: Modern controls inspired by macOS and Windows, backed by semantic themes and multiple sizes.
• 120 FPS: GPU-accelerated interfaces that remain smooth under load.
• Data Tables: Virtual scrolling, fixed and resizable columns, sorting, and cell selection across hundreds of thousands of rows.
• Virtual Lists: Render only the visible range, including lists whose items have different sizes.
• Code Editor: Stable performance at 200K lines with Tree-sitter highlighting and LSP diagnostics, completion, and hover.
• Dock Layout: Resizable panels, draggable tabs, nested splits, and edge docks — all serializable.
• Rich Content: Native Markdown and HTML rendering, syntax highlighting, and built-in charts.
• Design Freedom: Use the complete visual system or build your own on the behavior and infrastructure in gpui-base.
• JavaScript Extensions: gpui-shell lets a shipped Rust host load panels and business logic as scripts, with every capability granted explicitly.
• Cross Platform: Ship one Rust codebase to macOS, Windows, and Linux.

Framework Architecture

Three layers. One ecosystem.

Use gpui-component to keep the application coherent with one complete visual and interaction system. Use gpui-base when your product needs to create and own that system itself. Use gpui-shell when the application should be extensible in JavaScript after it ships.

gpui-component	gpui-base	gpui-shell
Complete, styled components	Unstyled behavior and infrastructure	JavaScript runtime hosted by Rust
Productive defaults with theming	Full control over structure and visual design	Capabilities granted one at a time
Best for building applications	Best for building design systems	Best for plugins and scripted applications

                             APPLICATION
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
              ▼                   ▼                   ▼
    ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
    │  gpui-component  │ │ Your Design      │ │    gpui-shell    │
    │    Styled UI     │ │ System           │ │  JS extensions   │
    └────────┬─────────┘ └────────┬─────────┘ └────────┬─────────┘
             │                    │                    │
             └────────────────────┼────────────────────┘
                                  ▼
                        ┌──────────────────┐
                        │    gpui-base     │
                        │ Behavior · State │
                        │ Infrastructure   │
                        └────────┬─────────┘
                                 ▼
                               GPUI

Behavior belongs to the foundation. Presentation belongs to the application.

Use gpui-component when you want polished controls ready to ship. Build on gpui-base when your application should own its component source, layout, styling, and motion while reusing difficult interaction behavior. Add gpui-shell when contributors should extend the product without a fork or a release.

The layering follows the same separation that makes the shadcn ecosystem flexible:

This is the beginning of the README. Read the rest at the original. Read the full README ↗