A native desktop client in Rust (GPUI), as an alternative to the Electron shell

[phillip-hirsch]

I rewrote the T3 Code desktop client as a native Rust app built on GPUI (via gpui-kit). It talks to the same apps/server over the same WebSocket contracts, unchanged. I'd like to know whether you want any part of this upstream, and in what form, before I open a PR. CONTRIBUTING asks for that agreement first.

What it is

• apps/desktop-gpui, one binary (t3-desktop). It starts and supervises the bundled server the way the Electron main process does (same backoff, same exit-code handling) and connects to saved and remote environments the same way.
• The goal was to match the web UI and behavior exactly, control by control: sidebar shelves, composer, timeline, pull requests, settings, terminal, right panel, palette, keybindings and multi-environment.
• It builds and runs on Windows, macOS and Linux (X11 and Wayland), with the platform behavior Electron has there: frameless window with drawn caption buttons on Windows and Linux, native traffic lights and menus on macOS, t3code:// handoff, single instance and keychain credentials.
• No unsafe in the crate (#![forbid(unsafe_code)]). Three GPUI crates are vendored from crates.io with small patches: a safe setter, two bug fixes and one small addition (textarea decorations).
• About 705 unit tests (the count varies a little by platform), clippy clean with a strict lint table on all three platforms.

Numbers

Same machine, same seeded database, same server bundle (Nightly 0.1.10-nightly.20261111) for both apps, each in its own scratch profile. "Client" excludes the server process. Medians of 5 runs per app, measured November 11.

Windows 11, i7-8700K (12 threads), 32 GB, 144 Hz display:

	Electron Nightly	GPUI
Window shown	1066 ms	684 ms
Client processes	4	1
Client private memory	381 MB	140 MB
Client working set	748 MB	95 MB
Client CPU while idle (30 s, after a 20 s settle)	2.9% of one core	0.05% of one core
Install size	761 MB	129 MB exe

macOS, MacBook Pro M3 Pro, 36 GB:

	Electron Nightly	GPUI
Window shown	489 ms	375 ms
Client processes	4	1
Client memory footprint	625 MB	260 MB
Client resident memory	763 MB	151 MB
Client CPU while idle (30 s)	4.7% of one core	1.1% of one core
App size	487 MB	124 MB binary

The GPUI app runs the server on the system Node, and Electron runs it on its bundled one, so server memory differs: 289 vs 246 MB on Windows, 344 vs 252 MB on macOS. On macOS, GPUI's server also found the installed CLI providers and Electron's didn't. The GPUI binary includes the Office document viewer and isn't stripped yet.

Correction: the first version of this post gave GPUI's idle CPU on Windows as 0.2%. In most of those runs the display had gone to sleep, which stops GPUI's repaint loop. With the display on it was about 1.5%, because GPUI's Windows layer woke on every display refresh even when nothing changed. A patch now pauses idle windows the way GPUI already does on macOS, which gives the 0.05% above.

What's missing

• Dictation and voice input.
• GitHub and GitLab reference autolinks in rendered Markdown.
• The secret-provider reference picker in Settings.
• "Add to chat" from the pull request panel (it starts a new thread instead).
• Packaging and installers: no signing, auto-update or t3code:// registration in an installer yet.
• On Linux, PDF preview and the Wayland screen-capture flow.
• The Device panel for simulators and emulators.
• Subagents running on another linked machine (they don't show yet).
• Dragging threads in the sidebar, and the sidebar collapsing on its own in narrow windows.

The cost

This is a second implementation of the client UI. Every change to apps/web that a desktop user can see needs a matching change in Rust, or the two drift. I've kept up with two upstream merges so far: about 25 client-visible PRs ported in one day, then a smaller batch of 10, of which 5 needed changes. Each port was checked against the web code it mirrors. So it's doable, but it's ongoing work, and it touches the "hit every surface" rule in AGENTS.md: desktop would no longer get web changes for free.

Questions

1. Is a native desktop client something you'd consider at all, given that cost?
2. If yes, in what form? A few options:
   • an experimental, opt-in build next to the Electron app, maintained here;
   • a separate repository that tracks this one and uses only the server and contracts;
   • neither, and this stays a fork.
3. If it lives here, which parts would you want reviewed first? The crate is large. The linked branch already splits it into 9 commits on top of main: the vendored crates, crate setup, icons, core logic (shell, server supervision, model), pages, and the workspace UI. I can split it further any way you prefer.

The code is on a public branch if you want to look before answering: https://github.com/phillip-hirsch/t3code/tree/feat/desktop-gpui/apps/desktop-gpui

[tdu-naifen]

@phillip-hirsch Did you try https://www.gpuix.dev before rewrite client parts into rust?

[phillip-hirsch]

@phillip-hirsch Did you try https://www.gpuix.dev before rewrite client parts into rust?

No 😭

[tdu-naifen]

@phillip-hirsch really appreciate your work on this! It’s impressive how quickly you’ve put this together.🔥🔥🔥

I’m also exploring a similar approach. A full rewrite in Rust could introduce some additional maintenance overhead, especially since the repo is still mostly TypeScript. GPUIX might be worth exploring. It could potentially give us the performance benefits of GPUI while keeping a React-like, declarative development experience. It might also reduce the amount of code we need to write and maintain compared to a full native rewrite.

I can post some updates once I’m finishing exploring and share in this thread. Thx for the good work!

[phillip-hirsch]

@tdu-naifen Thank you! You're right, it would probably require a lot of additional maintenance. I'm curious to see if GPUIX is able to be as performant as GPUI. Definitely let me know!

[phillip-hirsch]

Update: I picked up another $200 Claude sub so now the large-feature round is done, and the branch has been through a full review.

• Large features: the audit's 155 large items were split into 88 pieces of work. 75 are done and 11 are partly done. One turned out to match the web already, and one is blocked: the WSL backend.
• Upstream: the 72 client commits upstream shipped through d7c52f9f86 are ported. Each was reviewed against the web code it copies.
• Hands-on testing: I ran the app on Windows and macOS against the Replay provider through 12 flows, including queued messages, approvals, the terminal, the browser panel and relaunching. There were no crashes, and the three bugs it found are fixed.
• Review: after repeated area-by-area code reviews, Claude Opus, GPT Sol and Muse each reviewed the whole branch, then reviewed it again after fixes. Their verdict: it's ready to try as an opt-in build you compile yourself, but it doesn't replace the Electron app yet.
• Checks: about 1,640 tests, and clippy is clean on Windows, macOS and Linux. CI now runs the Linux build and tests, and fails if the Rust settings stop matching the TypeScript contract.

Still left:

• About 1,130 medium and low findings from the audit. Many were probably fixed along the way, so they need re-checking first.
• Shipping it: bundling Node and the server, installers, signing and auto-update.
• T3 Connect, voice input and the Device panel.

I've refreshed the branch linked in the post above, feat/desktop-gpui. It now has the current code in 9 commits on top of upstream d7c52f9f86, so it can be reviewed piece by piece.

The questions in the original post still stand.

[davidbuzz]

solid work. rust for accelerated desktop apps , particularly as a result of Zed (editor) very performant. here's something similiar i did in rust, and using the same ecosystem: https://github.com/davidbuzz/MissionPlannerRust