Overview of 1043: I’m Using GPUI For Everything
In this episode, Wes Bos and Scott Tolinski dig into GPUI, the GPU-accelerated UI framework from the Zed team, and why Scott has been using it to build fast, lightweight desktop apps in Rust. The conversation compares GPUI with Electron and Tauri, explains how GPUI’s API feels surprisingly familiar to React developers, and explores real-world use cases, component libraries, and current limitations.
What GPUI Is
- GPUI is a GPU-accelerated UI framework built in Rust.
- It’s designed for building desktop apps without shipping a browser/WebView like Electron.
- It supports macOS, Linux, Windows, and has experimental paths for web and mobile.
- Unlike Electron, GPUI is not a “wrap a web app in a shell” solution—it’s a from-scratch UI system.
How It Compares to Electron and Tauri
Electron
- Uses a bundled Chromium instance.
- Powerful and familiar, but often large and resource-heavy.
- Great when you want full browser feature parity and predictable behavior.
Tauri
- Uses the system WebView and Rust on the backend.
- Smaller than Electron, but the native WebView can be inconsistent and feature-limited, especially on macOS.
GPUI
- Avoids WebView entirely.
- Trades browser compatibility for:
- Speed
- Smaller app size
- Tighter control
- Rust-native logic and rendering
Why Scott Likes GPUI
Scott’s main argument is that GPUI is a great fit for small, fast, personal desktop utilities where Electron would feel too heavy.
Benefits he highlighted
- Very fast and GPU-accelerated
- Lightweight compared to Electron apps
- Lets him build “thin” desktop tools without shipping Chromium
- Rust logic lives right alongside the UI, so there’s no extra RPC/message layer for many app actions
- Feels good for vibe coding and rapid personal software experiments
Developer Experience and API Feel
GPUI feels React-like, but not React itself.
Similarities to React
- Components
- Props
- State
- Render functions
- Event handlers like click actions
Differences
- It’s not using the DOM
- UI is built from primitives like
div,flex, etc. - Styling is more like chained utility methods, with a bit of a Tailwind-like feel
- State updates require an explicit
notify()call to trigger re-rendering, which Scott compared to a Remix-like update flow
Styling and Layout
Scott said GPUI’s styling system covers a lot of the common UI needs:
- Flexbox-style layout
- Padding, borders, shadows
- Text sizing and color helpers
- Focus states
- Animations and transitions
Notable limitation
- He did not find strong evidence of Grid support in his experience, and most of what he used was built with flex.
GPUIKit: The Component Library Unlock
A major part of the episode is GPUIKit, a component library for GPUI that Scott says dramatically reduces the “rebuild everything yourself” problem.
What it provides
- Accordions
- Alerts
- Dialogs
- Badges
- Carousels
- Inputs
- Comboboxes
- Command inputs
- Data tables
- Virtualization
- Sorting
- Popovers
- Pagination
- And more
Why it matters
- Makes GPUI much more practical for real apps
- Gives you ready-made primitives that are still customizable
- Scott compared it to something like shadcn/ui, but for GPUI
Community Fork / GPUI CE Discussion
The episode briefly touches on a community fork sometimes referred to as GPUI CE.
Key point
- There’s some community frustration that the Zed team prioritizes features that serve Zed’s needs first.
- The GPUIKit maintainer reportedly prefers sticking with upstream GPUI rather than supporting the fork.
- Scott and Wes keep the discussion high level and mostly focus on what’s working for them now.
Apps Scott Built With GPUI
Scott shared several personal tools he’s building with GPUI:
1. Gendo
- A utility for managing and viewing projects across his Macs
- Helps track which projects are running, where they live, and their status
- Built for managing multiple machines and dev environments
2. File Bro
- A file automation app inspired by tools like Hazel
- Can help with rules like:
- Move files based on name/type
- Check duplicates
- Merge files
- Run file analysis
- Originally an Electron app, now being moved to GPUI/Rust for speed and lightness
3. Mr. Space
- A window management utility
- Lets Scott send windows to spaces, pin them left/right, and manage layouts more flexibly
- Uses macOS native spaces
- He notes GPUI is even used here just for the settings menu, showing it can be used for small UI surfaces too
Downsides and Tradeoffs
Scott was clear that GPUI is not ideal for every project.
Main drawbacks
- Not native UI
- You don’t get system-native widgets by default
- If you want a Mac-native “Liquid Glass” look or equivalent platform-native feel, you’ll need to build it yourself
- No DOM
- Web tooling and browser-based automation don’t apply directly
- Young ecosystem
- Still early compared to Electron or web tooling
- Cross-platform doesn’t mean write-once-everywhere
- It’s not a “build once and get web + desktop + mobile” framework in the same way people might hope
Testing and Automation
One interesting point:
- Because GPUI doesn’t use the DOM, browser-based testing tools won’t work the usual way.
- Scott mentions experimenting with computer-use-style testing via the accessibility tree.
- He’s also built a GPUI testing setup driven by Jev, using the accessibility tree instead of screenshots.
Mobile Support
- GPUI mobile exists and is experimental.
- It appears to work via WGPU/Metal on iOS.
- Scott is skeptical about using it for a full native mobile app, but acknowledges it’s promising for certain use cases.
Best Fit Use Cases
Scott’s recommendation is pretty specific:
GPUI is a good fit for:
- Small desktop utilities
- Personal software
- Fast, lightweight internal tools
- Apps where you want Rust logic + custom UI
- Projects where shipping a huge Electron app would feel excessive
GPUI is probably not the best choice for:
- Web apps
- Apps that need a fully native platform look and feel out of the box
- Projects that rely heavily on the browser DOM ecosystem
- Teams that want the broadest possible mature tooling today
Key Takeaways
- GPUI is a serious alternative for Rust-based desktop UI development.
- Its biggest advantage is speed + control + small footprint.
- The experience is surprisingly familiar to React developers, even though it’s built very differently.
- GPUIKit is a major practical unlock because it gives you the component ecosystem you’d otherwise have to build yourself.
- It’s still early, but for Scott’s use case—small, fast, custom desktop apps—it’s becoming his default choice.
Bottom Line
Scott’s core message is simple: if you’re building desktop-first personal software and want something lightweight, fast, and Rust-native, GPUI is worth a serious look. It’s not a universal replacement for Electron or Tauri, but for the right class of app, it may be the exact tool he’s been wanting for years.