Skip to content

About

C++ port of GPUI rust UI library from Zed

Resources

Stars

19 stars

Watchers

1 watching

Forks

Latest commit

 

History

2,461 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

gpui for C++

A C++ port of longbridge/gpui-kit, a Rust UI kit built on Zed GPUI. Targets Windows, Linux, macOS, iOS, Android, and the browser (wasm).

Original project:

This tree reimplements the component examples and a small runtime on top of the OS: Win32 + Direct2D + DirectWrite on Windows, X11 + cairo + Pango on Linux, Cocoa + Core Graphics + Core Text on macOS, an application-supplied native host on iOS and Android, and a <canvas> 2D context in the browser. Everything above the paint.h / platform.h seam is shared. It is not a binding to the Rust crates, and it does not use Blade or Zed’s renderer. Layout is the exception: src/taffy/ is a C++ port of the taffy crate GPUI itself lays out with, at the version gpui-kit pins.

The API follows GPUI's shape: an App owns the entity store and the windows, a Window renders a view, and a view is a struct with state plus static El* Render(T* self, Ctx* cx):

struct Example {
    static void OnGo(Example*, Ctx*, const ClickEvent*) { log(StrL("Clicked!")); }

    static El* Render(Example*, Ctx* cx) {
        return Div(cx->a)->FlexCol()->SizeFull()->ItemsCenter()->JustifyCenter()
            ->Child(TextEl(cx->a, StrL("Hello, World!")))
            ->Child(ButtonEl(cx->a, 0, StrL("Let's Go!"), BtnKind::Primary)
                        ->OnClick(Listen(cx, &Example::OnGo)));
    }
};

int GpuiMain(int argc, char** argv) {
    App* app = AppNew();
    component::Init(app);
    // gpui_kit::open_window: the window's root is a Root around the view, so
    // dialogs, sheets and notifications work in it.
    return KitRunView(StrL("Hello World"), 800, 600,
                      EntityNew<Example>(app).id, app, WinOpts{});
}

Entities are generational handles owned by App, not refcounted; cx.listener becomes Listen(cx, &T::Handler) and cx.notify() becomes Notify(cx). See the App, Window, Entity, Ctx section of AGENTS.md.

The Rust sources used as the spec live in a gitignored clone at .work/gpui-component/. Exact checkins we are porting are in cmd/run.ts; bun cmd/build.ts installs that tree. Ingesting later upstream checkins: the /update-port skill (.claude/skills/update-port/SKILL.md).

Build

bun cmd/build.ts and bun cmd/run.ts dispatch to the toolchain for the machine they run on, so the same commands work on all three platforms:

bun cmd/build.ts -rel story
bun cmd/run.ts -rel -compare story
# compile every source file as a separate object and link a header-only example
bun cmd/build-no-amalgam.ts -rel
bun cmd/build-no-amalgam.ts -clang -rel   # Windows: clang-cl
# arm64 static libraries for externally hosted mobile applications
powershell -ExecutionPolicy Bypass -File cmd/android-install-deps.ps1
bun cmd/mobile-build.ts -android -rel
bun cmd/mobile-build.ts -ios -rel         # macOS + Xcode only
bun cmd/mac-build.ts -ios -rel            # from a Windows/Linux checkout

bun cmd/build.ts with no example name lists targets (system_monitor, showcase, story, …).

Rust/C++ parity suite

On Windows, the parity suite builds the pinned Rust story application and this port, drives identical native input through both, and compares screenshots at each checkpoint:

bun cmd/parity.ts
bun cmd/parity.ts -nobuild input-edit select-open
bun cmd/parity.ts -list

The default cases cover static composition, toggles, text input, overlays, scrolling, pointer capture and retained tree state. Each checkpoint has a checked-in percentage budget for ordinary renderer and text-antialiasing differences; interactive checkpoints must also prove that both applications changed. Captures plus machine-readable JSON and Markdown reports are written to out/parity/. -report records results without failing on an exceeded visual budget, for deliberately investigating a known difference. -nobuild assumes both existing executables were built from the current pin; run the default command after moving an upstream pin.

To lint every source translation unit under src/ with LLVM's clang-tidy (using the repository's .clang-tidy configuration):

bun cmd/clang-tidy.ts
bun cmd/clang-tidy.ts -checks=bugprone-*,performance-*
bun cmd/clang-tidy.ts --host       # only this platform's source files

On Windows the renderer is Direct2D on a D3D11 device; two more renderers were measured against it and removed, see obsolete-windows-backends.md. __scene=off makes the element tree draw straight to the backend instead of through the scene (the default, which skips unchanged frames and redraws only what changed). __layout_reuse=off|on rebuilds the taffy tree every frame when off (default on); GPUI_LAYOUT_REUSE is the same switch if argv did not set it. The runtime consumes those reserved arguments before calling GpuiMain, so application argument parsing never sees them.

Markdown defaults to the complete CommonMark + GFM parser. Applications that prefer a smaller executable can select the basic parser at build time:

bun cmd/build.ts -markdown=mini -rel story
bun cmd/build.ts -markdown=full -rel story   # default

The mini feature list and intentional omissions are in src/markdown-mini/readme.md.

HTML parsing has the same build-time choice. The html5ever port is the default; the former reader-mode parser is the smaller drop-in implementation:

bun cmd/build.ts -html=mini -rel story
bun cmd/build.ts -html=full -rel story   # default

See src/html5ever/readme.md and src/html5ever-mini/readme.md.

JavaScript shell

gpui_shell runs the port of crates/shell against the vendored, pinned QuickJS-NG engine. The upstream todo application is included unchanged:

bun cmd/run.ts -rel gpui_shell -- examples/js_todolist --dev
bun cmd/run.ts -rel gpui_shell -- check examples/js_todolist
bun cmd/run.ts -rel gpui_shell -- types examples/js_todolist

gpui_shell carries the gpui-component catalog (src/component_shell, the port of crates/component-shell), so the upstream JavaScript component gallery runs unchanged too:

bun cmd/run.ts -rel gpui_shell -- examples/js_story

The first command opens the application and reloads it after source changes. check loads and renders once without a window; types writes the exact upstream gpui.d.ts plus declarations for registered host modules. A directory may optionally carry gpui-shell.json to set its entry point, capabilities and plugin metadata. gpui_shell is a desktop target and is skipped by -wasm.

Windows needs Bun and the MSVC C++ toolset. cl.exe on PATH is used as it is; otherwise Visual Studio is found through vswhere and its vcvars64.bat is read for the environment, so a plain shell builds. bun cmd/build.ts -clang <example> builds with clang-cl from the same toolset instead.

Linux needs g++ (or clang++), pkg-config and the X11 / cairo / pango dev packages. libcurl (remote images) and WebKitGTK 4.1 (the webview) are used when installed and skipped when not. On Ubuntu or Debian:

bash cmd/ubuntu-install-deps.sh

macOS needs the Xcode command line tools (xcode-select --install).

The browser is a target rather than a host, so it is asked for by name and builds from any of the three:

bun cmd/build.ts -wasm story
bun cmd/run.ts -wasm story         # builds, serves, opens a tab

It needs emscripten, found through $EMCC, $EMSDK, PATH, or an emsdk checkout beside this one:

git clone https://github.com/emscripten-core/emsdk ../.emsdk
cd ../.emsdk && ./emsdk install latest && ./emsdk activate latest

There is no other dependency: the page draws through Canvas2D. What a tab cannot do that a desktop can — a second window, a background thread, a blocking fetch, the machine's process table — is listed in AGENTS.md.

From a Windows checkout you can build and run the Linux binaries under WSL without leaving the shell, and compile the macOS ones on a Mac over ssh:

bun cmd/wsl-run.ts -rel system_monitor
bun cmd/mac-build.ts -rel -all

CI compiles every example and runs the tests on all three desktop platforms and wasm on each push, and cross-compiles the library with the Android NDK and iPhoneOS SDK. It also checks separate translation units on every desktop, clang-cl/clang++ on Windows and Linux, and the mini markdown parser (.github/workflows/build.yml).

Why port to C++?

  • Do you know a good joke?
  • Yes, Rust.

About

C++ port of GPUI rust UI library from Zed

Resources

Stars

19 stars

Watchers

1 watching

Forks

Releases

Packages

Contributors

Languages