Avalonia vs GPUI

Zed builds GPUI for Zed. We build Avalonia for you.

Trusted by industry leaders and developers worldwide

How they differ

One framework is the product. The other is part of one.

Avalonia is what we make. GPUI is what Zed is made with.

Zed wrote GPUI to draw its code editor, and it does that very well: Zed is fast, and GPUI is why. It’s open source, so other teams have started building on it. What they’re building on is one company’s editor engine.

AvaloniaGPUI
Built by
Avalonia
A UI framework company

21 people whose product is the framework, its tooling and its support.

GPUI
A code editor company

Zed Industries, which makes the Zed editor and sells plans for it.

Built for
Avalonia
Other people’s applications

Desktop, mobile, browser and embedded products we’ll never see the source of.

GPUI
Zed

The crate describes itself as “Zed’s GPU-accelerated UI framework”.

A feature gets in when
Avalonia
Applications need it

No one application decides what gets built.

GPUI
Zed needs it

Outside changes with no Zed use case have been closed unmerged.

The version number
Avalonia
12.0, a long-term support line

In development since 2013. Every major version, and every fourth minor release after it, is designated LTS.

GPUI
0.2.2, pre-1.0

Its README expects breaking changes between versions.

In one line

A framework that is its maker’s business.

A framework that serves its maker’s business.

Why it matters

A UI framework is a dependency you keep for the life of the product. Rendering, text and input sit too deep in an application to swap later. So the question that outlasts any benchmark is who decides what the framework does next, and what pays them to care.

Sometimes the answer is GPUI.

GPUI gives a Rust team the renderer behind a fast editor, at the price of living on Zed’s roadmap. Avalonia gives you a framework with a company behind it, at the price of a .NET runtime in the box.

Choose Avalonia when

You’ll still be shipping this in ten years.

  • People who haven’t joined yet will maintain it
  • You need controls as well as drawing: text input, lists, menus, dialogs
  • Someone has to answer when it breaks, and LTS releases carry five years of security updates
  • Mobile, the browser or embedded Linux might matter one day
  • Your team writes C#, or writes Rust and would rather bind to a mature framework

GPUI is a fair choice when

You’re building something shaped like Zed.

  • It’s a keyboard-driven, text-heavy desktop tool, which is what GPUI was written to draw
  • The whole stack must be Rust, with no second runtime in the process
  • You’re happy to pin a commit and read Zed’s source as the documentation
  • You’d maintain a fork if your needs and Zed’s part ways

Who maintains it

The framework is the whole company.

Nothing we sell works without Avalonia, which keeps our priorities simple.

2013

In development since

13+ years of development, MIT licensed the whole time.

21

Avalonians, in 11 countries

One product line: the framework, its tooling and its support.

6

Platforms from one codebase

Windows, macOS, Linux, iOS, Android and WebAssembly.

Five years

Security updates on an LTS release

Under Avalonia Enterprise. 12.0 is the current LTS line.

Shipping today

Other companies’ products are the point.

GPUI’s reference application is its maker’s own. Avalonia’s include a profiler from JetBrains, Unity’s version-control client and a design tool used by millions.

“As our tools use WPF, Avalonia was an easy choice for us.”

The dotTrace and dotMemory team

JetBrains dotTrace on macOS, showing a performance trace with a threads timeline, hotspots and a call tree

Three codebases became one.

WinForms, GTK# and Xamarin.Mac, replaced by a single client.

Daniel Peñalba, Unity Version Control

Developers compiled Avalonia applications 410M times in the first half of 2026.

5.7M

Projects built on Avalonia

Icons8 Lunacy

Lunacy runs on Windows, macOS, Linux and the browser.

The Lunacy design application on macOS, showing a vector canvas, a layers panel and an inspector

The dependency

Depend on GPUI, and you depend on Zed’s roadmap.

Zed is candid about what GPUI is for, which is to its credit. Everything below comes from Zed’s repository, the public registry and GPUI’s own community fork.

Pre-1.0, by its own README.

“GPUI is still in active development as we work on the Zed code editor, and is still pre-1.0. There will often be breaking changes between versions.”

No Zed use case, no merge.

On 12 December 2025 a Zed maintainer closed outside pull requests for system tray support, custom shaders and Wayland touch input with one reply: “we’re shifting focus to core product work at Zed, and without a Zed use case, I can’t validate this code”.

A fork started the same day.

GPUI Community Edition was created on 12 December 2025. Its own site gives the reason in one sentence: “GPUI was built to serve one editor’s roadmap.”

The documentation is Zed’s source code.

“Currently, the best way to learn about these APIs is to read the Zed source code or drop a question in the Zed Discord.” The newest release on crates.io is 0.2.2, from 22 October 2025.

For Rust developers

Want Rust? Write Avalonia in it.

Rustolonia is a Rust binding to Avalonia, built by Devolutions.

Avalonia’s controls, written as Rust.

An rsx! macro builds the control tree, signals carry the state and closures handle the events. A code-first app needs Cargo and nothing else: the first build downloads a prebuilt Avalonia 12.1 host and checks its SHA-256.

  • No .NET SDK to install, and Rust 1.88 or newer
  • Windows, macOS and Linux, on x64 and arm64
  • Android and the browser too, with iOS and embedded Linux marked experimental
let clicks = scope.signal(0_u32);
scope.mount_view(rsx! {
    Window {
        title: "Hello from Rust",
        StackPanel {
            orientation: Orientation::Vertical,
            margin: 24.0,
            spacing: 12.0,
            TextBlock { "Welcome to Avalonia!" }
            Button {
                class: "primary",
                on_click: move |_| clicks.update(|c| *c += 1),
                content: fmt!("Clicked {} times", clicks.get())
            }
        }
    }
})?;

A PDF viewer, written in Rust.

One of the sample apps in the Rustolonia repository, running on macOS. Rust parses the document and rasterises each page with PDF Oxide, and Avalonia draws the window around it.

  • Rust owns parsing, rendering, search and navigation
  • The interface is compiled AXAML, bound to Rust view-models
  • Also in the repository: a system monitor and an archive manager
The PDF viewer sample from the Rustolonia repository running on macOS: a bookmarks pane, a rendered page of an annual review, and a panel of the text extracted from it

Built by Devolutions, who ship on Avalonia.

Devolutions moved Remote Desktop Manager’s Windows interface to Avalonia, view by view, while it kept shipping. Rustolonia is the same company’s work, MIT licensed and in the open on GitHub.

Remote Desktop Manager by Devolutions, with its interface built on Avalonia

Side by side

The whole comparison, including the rows GPUI wins.

Twenty-two rows, no ticks and no crosses. Ties are set back, and the last group points GPUI’s way on purpose.

AvaloniaGPUI

Who it’s for

Maintained by
AvaloniaAvaloniaUI OÜ
GPUIZed Industries
What the maintainer sells
AvaloniaTooling, components and support for the framework
GPUIPlans for the Zed editor
Built for
AvaloniaApplications outside the company
GPUIThe Zed editor
Commercial support
AvaloniaFrom the maintainers, with Avalonia Enterprise
GPUINone offered for GPUI

Releases

Current version
Avalonia12.0, a long-term support line
GPUI0.2.2, pre-1.0
Breaking changes
AvaloniaHeld for major versions, enforced in CI
GPUI“Often”, by its README
Packaged releases
AvaloniaEvery release, on NuGet
GPUI0.2.2 on crates.io, from October 2025
Long-term support
AvaloniaLTS lines carry five years of security updates
GPUINo policy published
Framework licence
AvaloniaMIT
GPUIApache-2.0

Where it runs

Windows
AvaloniaSupported
GPUISupported
macOS
AvaloniaSupported
GPUISupported
Desktop Linux
AvaloniaSupported
GPUISupported
iOS and Android
AvaloniaSupported
GPUINot documented
Browser
AvaloniaSupported, via WebAssembly
GPUINot documented
Embedded Linux
AvaloniaSupported, framebuffer or DRM
GPUINot documented

Building an application

Stock controls
AvaloniaButtons, text input, lists, menus and dialogs, in the framework
GPUILayout, text, lists, images and a canvas; the rest you build
Licence of the maker’s components
AvaloniaMIT, with the framework
GPUIGPL-3.0-or-later, in Zed’s separate component crate
The interface is written in
AvaloniaXAML or C#
GPUIRust, with Tailwind-style methods
Documentation
AvaloniaA documentation site with guides and an API reference
GPUIThe README, examples and Zed’s source

Rust, where GPUI leads

Rust support
AvaloniaThrough Rustolonia, a binding from Devolutions
GPUINative: the framework is Rust
Maturity of the Rust API
AvaloniaExperimental, first released October 2026
GPUIThe API Zed itself is built on
Runtime beside your code
AvaloniaA .NET host, compiled ahead of time
GPUINone

Checked 18 November 2026. GPUI’s README names macOS, Linux, FreeBSD and Windows; Zed’s repository also holds iOS and web crates the README doesn’t mention, so those rows say “Not documented”. Tell us if we’re behind.

FAQ

The questions
the evaluation asks.

If you’re weighing this up for a real product and something here doesn’t cover it, ask us directly.

It proves GPUI is a very good engine for Zed, which is what it was written to be. The open question for your product is what happens at the edges Zed doesn’t have. On 12 December 2025 Zed closed outside pull requests for system tray support, custom shaders and Wayland touch input, because there was no Zed use case to test them against. If your application looks like a code editor, that may never bite. If it doesn’t, you’ll reach those edges before Zed does.

It’s a fork of GPUI, created on 12 December 2025, the day Zed closed those pull requests, so the framework could take changes Zed doesn’t need. It’s an active project. It also means there are now two GPUIs, and the fork’s README says of the original: “It’s mostly API compatible with upstream, but that is changing!” Choosing it means betting on a community fork keeping pace with an upstream that’s tuned for one editor.

We haven’t measured one against the other, and we don’t publish framework benchmarks, ours or anyone’s: the numbers depend on the application more than the framework. GPUI was written to draw a code editor at a high frame rate, and Zed shows that it does. Avalonia draws its own interface on the GPU too. Measure your own workload on both; that’s the only number that matters.

No. GPUI is Apache-2.0 and Avalonia is MIT, and both are permissive. One thing to check before you copy code: the components Zed built on top of GPUI live in a separate crate licensed GPL-3.0-or-later, so they can’t go into a closed-source application.

Optional products on top of a free framework: developer tooling such as Avalonia DevTools and Parcel, commercial components such as charts and the PDF viewer, Avalonia XPF for running WPF codebases cross-platform, and Avalonia Enterprise, which bundles support and LTS access. None of them is required to build or ship, there’s no per-seat framework licence, and the framework stays MIT whatever you decide about the paid products.

Build on a framework that’s somebody’s day job.

One codebase for Windows, macOS, Linux, mobile and the browser, MIT licensed, from C# or from Rust.