Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

GPUI vs Rune

Key differences, specifications and fit guidance for GPUI and Rune, compiled from official documentation and the iThub profiles.

Web Frameworks & UI LibrariesBy iThub editorial teamUpdated 7 min read26 official sources0 views

GPUI is the hybrid immediate and retained mode, GPU-accelerated UI framework for Rust behind the Zed editor. It renders with Metal, DirectX 11 or wgpu, styles views with a Tailwind-like API and is published on crates.io under Apache-2.0.

Pricing
Open source · Free edition or plan
Deployment
Self-hosting not recorded
Source
Open-source edition
Platforms
macOS, Linux

Rune is an MIT-licensed, pre-release Rust UI framework from Anomaly with its own GPU renderer, Taffy layout, Parley text and spring animation, targeting macOS, Windows, Linux, iOS and WebGPU, with headless rendering for agents.

Pricing
Open source · Free edition or plan
Deployment
Self-hosting not recorded
Source
Open-source edition
Platforms
Windows, macOS, Linux
On this page
  1. Quick verdict
  2. Key differences
  3. Specifications
  4. What are GPUI and Rune?
  5. How to evaluate
  6. FAQ
  7. Sources

Quick verdict

Choose GPUI if you want the UI framework the Zed editor is built on: it is published on crates.io under Apache-2.0, draws with Metal, DirectX 11 or wgpu on macOS, Windows and Linux, and keeps state in entities owned by the framework. Choose Rune if you want views written as plain Rust functions of your state, spring animation built in, iOS embedding in UIKit or SwiftUI, and headless PNG and element-tree output that coding agents can check. Rune is a pre-release MIT project added from Git at a pinned commit, while GPUI is pre-1.0 with frequent breaking changes.

Choose GPUI if

Shortlist GPUI when you are building a desktop application for macOS, Windows or Linux, want a crate published on crates.io under Apache-2.0, and are comfortable learning from the Zed source code and following breaking changes before 1.0.

Choose Rune if

Shortlist Rune when you want views written as plain Rust functions of state with spring animation built in, need iOS embedding or an experimental WebGPU canvas from the same code, or want coding agents to check UI work through headless PNGs and element trees, and you can pin a Git revision.

Key differences

Key differences between GPUI vs Rune
AspectGPUIRune
Origin and purposeZed Industries develops GPUI for the Zed code editor as a hybrid immediate and retained mode, GPU accelerated framework. gpui.rs credits the creators of Zed and Delta and says GPUI implements the features those two apps need first, plus community requests.Built by Anomaly as a native GPU-rendered Rust UI framework with its own renderer, text, layout and springs. Its public page calls OpenCode's desktop app the test Rune is built against, and every app can run headless so coding agents can check their work.
Rendering backendsMetal on macOS, DirectX 11 on Windows and wgpu on Linux, where X11 or Wayland handles windowing. Text on Windows uses DirectWrite, and glyph rasterization on macOS needs the font-kit feature.Rune's own Metal backend on macOS, wgpu on Windows and on Linux, and WebGPU on a single canvas in the browser, with an optional WebGL2 fallback. Each frame is drawn by one instanced uber-quad pipeline in one draw call.
Platforms: desktop, web, iOSThe README covers macOS, Windows, and Linux or FreeBSD with Wayland or X11. The Zed repository also holds a gpui_web crate whose hello_web example builds for wasm32 on nightly Rust with Trunk. Neither the README nor gpui.rs documents iOS.One codebase targets macOS, Windows, Linux with X11 and Wayland, iOS and the web. On iOS, Rune is embedded in UIKit or SwiftUI views; the web target is experimental and builds for wasm32-unknown-unknown.
API style and state modelState lives in entities owned by GPUI and reached through Rc-like smart pointers. A view is an entity implementing Render, styled with a Tailwind-style API, and a handler calls cx.notify() to request a new render. Low-level elements give imperative control.A view is a plain Rust function of your state that returns elements, with no markup and no macro language. Press handlers are queued and run between frames with mutable state, then the view runs again and elements given motion move on springs.
Distribution and versioningPublished on crates.io as gpui, newest release 0.2.2 from October 22, 2025, with API docs on docs.rs. That release's README asks for macOS or Linux and starts apps with Application::new(), while the main-branch README adds an optional gpui_platform crate and Windows setup notes.Not on crates.io: you add it as a Git dependency pinned to a revision of the dev branch, which is never rewritten. The core crate declares version 0.0.1, and apps must repeat Rune's crates.io patch entries in their own workspace.
LicenceApache-2.0, declared in the gpui crate manifest, with copyright held by Zed Industries. The Zed editor crate in the same repository is GPL-3.0-or-later, so check the licence of any other Zed crate you copy.MIT License, copyright 2026 Anomaly, set for the whole workspace in Cargo.toml. The project does not take pull requests; bugs and ideas go to GitHub issues instead.
MaturityPre-1.0 and in active development alongside Zed, with frequent breaking changes between versions. Contributions go through the Zed repository and stay in sync with the editor, and the README points to the Zed source code as the best way to learn the APIs.Pre-release with no releases yet. The changelog lists changes that can move an app's output without a code change, so upgrading means reading it before you move your pinned revision.
Testing and accessibilityThe gpui::test macro and TestAppContext let tests simulate common platform input. GPUI exposes an accessibility tree through AccessKit, and developers are responsible for making custom controls accessible.Any app renders headless to a PNG with --snap, to a strip of frames with --frames, and prints its element tree with --tree. Tests drive the real runtime by key and clock. Accessibility is a default feature, built on patched AccessKit adapters.

More specifications

From the iThub profiles. “Not recorded” means the profile does not confirm it. Confirm prices and editions with each vendor.

GPUI vs Rune specifications
AttributeGPUIRune
Starting priceFree edition or planFree edition or plan
Open-source editionYesYes
Self-hostingNot recordedNot recorded
APINot recordedNot recorded
FoundedNot recorded2026
HeadquartersNot recordedNot recorded
GitHub stars95.2K ↗6.2K ↗
DocumentationOfficial docs ↗Official docs ↗

What are GPUI and Rune?

GPUI

GPUI is the user interface framework that Zed Industries develops for the Zed code editor. Its README describes it as a hybrid immediate and retained mode, GPU accelerated UI framework for Rust, designed to support a wide variety of applications. GPUI draws its own interface with the GPU instead of embedding a browser or using platform-native widgets. The GPUI examples guide lists Metal on macOS, DirectX 11 on Windows and wgpu on Linux, where X11 or Wayland handles windowing. The project site gpui.rs presents GPUI as coming from the creators of Zed and Delta.

GPUI has no repository of its own. It is the crates/gpui crate inside the zed-industries/zed repository, next to platform crates such as gpui_macos, gpui_windows, gpui_linux, gpui_web and gpui_platform. gpui.rs states that GPUI is tied to Zed for the near future, so contributions are made in the Zed repository and kept in sync with the editor. The gpui crate manifest declares the Apache-2.0 license, while the zed editor crate and Zed's ui component crate declare GPL-3.0-or-later.

Rune

Rune is a native, GPU-rendered user interface framework for Rust from Anomaly, published under the MIT license. It ships its own renderer, text stack, layout and spring animation instead of wrapping the platform widget toolkits, and the same code runs on macOS, Windows, Linux, iOS (embedded in UIKit or SwiftUI views) and the web. Views are plain Rust functions that return an element tree (fn view(s: &State, cx: &mut Cx<State>) -> El), with no markup and no macro language, and press handlers mutate application state between frames. The source lives in the anomalyco/rune repository on GitHub.

Rune is aimed at Rust developers who want an interface drawn entirely by their own application, and at teams whose coding agents write UI: every Rune application can run headless, render to PNG, dump its element tree and replay scripted input, and the README asks agents to start from examples/hello and check their work headlessly.

How to evaluate GPUI and Rune

Rune and GPUI are Rust UI frameworks that draw the whole interface on the GPU with their own renderer. GPUI is the framework Zed Industries builds for the Zed editor, published on crates.io under Apache-2.0, with entity-based state and a Tailwind-style API. Rune, from Anomaly, is a pre-release MIT framework added from Git, with views as plain functions of state, springs, iOS embedding and headless rendering for coding agents.

Start from the platforms you must ship on and how you will take updates. Decide whether the team can track a Git revision with no releases or needs a crates.io version, and whether a framework shaped by another product, Zed for GPUI and OpenCode for Rune, covers the widgets and patterns your app needs.

Criteria to verify

  • Target platforms, including iOS and the browser
  • crates.io release versus a pinned Git revision
  • State model: entities and notify versus view functions of state
  • Headless rendering and test tooling for CI or coding agents
  • Licence of every crate you depend on or copy

Proof-of-concept plan

Build the same small app in both frameworks: a list of a few thousand rows with a text filter, a settings form with a toggle and a text field, and a panel that streams text. Run it on each desktop platform you ship and add one automated UI test, then compare the code needed, the scrolling you measure yourself, the work of a version or revision upgrade and how a screen reader handles the controls.

Frequently asked questions

What is the difference between Rune and GPUI?

Both are Rust UI frameworks that render their own interface on the GPU. GPUI is the framework of the Zed editor, published on crates.io under Apache-2.0, with entity-based state and a Tailwind-style styling API. Rune comes from Anomaly, is MIT licensed and pre-release, is added from Git, writes views as plain functions of state, and adds iOS embedding, an experimental WebGPU web target and headless rendering for agents.

Is Rune on crates.io?

Not yet. Rune's own page says it is not on crates.io and should be added from Git at a commit, pinned to a revision of the dev branch. The crate called rune on crates.io is a different project: the Rune Language, an embeddable dynamic programming language for Rust, maintained in the rune-rs/rune repository. GPUI, by contrast, is published on crates.io as gpui.

Can Rune or GPUI run on iOS or in the browser?

Rune lists iOS, embedded in UIKit or SwiftUI views, and an experimental web target that renders one canvas through WebGPU, with an optional WebGL2 fallback. GPUI's README covers macOS, Windows and Linux or FreeBSD and does not document iOS. The Zed repository does include a gpui_web crate whose hello_web example targets wasm32 on nightly Rust, so test it before you plan a browser release.

Which licences do Rune and GPUI use?

Rune is released under the MIT License, copyright Anomaly, and the licence is set for the whole Rune workspace. GPUI is licensed Apache-2.0 in its crate manifest. Both are permissive, but GPUI lives inside the Zed repository, where the Zed editor crate itself is GPL-3.0-or-later, so check the licence of each crate you depend on or copy.

Are Rune and GPUI ready for production use?

Neither has reached 1.0. GPUI is still in active development alongside the Zed editor, is built primarily for Zed and Delta, and warns of frequent breaking changes between versions. Rune is pre-release with no releases yet, and its changelog lists changes that can alter an app's output without a code change. In either case, pin exact versions or revisions and budget time for upgrades.

Which framework fits apps built with coding agents?

Rune is designed for it: every app can run headless, rendering to PNG, dumping its element tree and taking scripted input, and the README tells agents to start from examples/hello and check their work headlessly. GPUI offers a test macro and a TestAppContext that simulates platform input, but its README says the best way to learn the APIs is currently to read the Zed source code.

Sources

Facts on this page come from these official pages, checked on , and from the iThub profiles. Vendors change plans and features: confirm with them before buying.

Comparisons are decision aids, not rankings. Read the evaluation methodology or report a correction.