Under the hood: how Zed actually works.

One decision everything else follows from.

VSCode is a web page that happens to edit code. WebStorm is a JVM application with a text-editing plugin at its center. Zed made a different call at the start: no DOM, no JVM — native Rust talks to the GPU directly.

GPUI — Zed's own UI framework.

• Every part of the editor's UI — buffer, tab bar, project panel, settings — renders through one framework, GPUI, straight to the GPU (Metal on macOS, Vulkan/OpenGL on Linux).
• It's a from-scratch Rust GUI toolkit, not an embedding of an existing browser or native-widget library. Zed's team took that on specifically to control text rendering and input latency end to end, rather than inheriting a general-purpose layout engine's trade-offs.
• GPUI is part of what Zed open-sourced — it's a real, usable Rust GUI framework other projects can build on, not an internal-only detail.

The Rope — how the text is actually stored.

A Rope is a balanced tree of text chunks instead of one giant string or a flat array of lines. Editors have used ropes and piece-tables for this reason for decades — VSCode's own Monaco editor uses a comparable piece-tree internally.

The CRDT layer — how concurrent edits actually merge.

Zed's own engineering blog documents this directly: buffers are an operation-based CRDT (Conflict-free Replicated Data Type) — the same family of data structure Figma uses for multiplayer design.

Tree-sitter — integrated by its own inventor.

• Tree-sitter builds an incremental syntax tree — after an edit, it reparses only the changed region, not the whole file. That's what makes structural highlighting and selection stay instant as files grow.
• Plenty of editors bolt Tree-sitter on afterward (Neovim, and VSCode partially, for some highlighting). Zed's co-founder Max Brunsfeld created Tree-sitter — the integration was designed alongside the editor, not adapted to fit one built for a different parsing model.
• It powers more than color: structural selection ("select the enclosing function"), code folding, and the syntax context AI features read from.

Language intelligence: the same protocol, a leaner client.

Zed doesn't reinvent language intelligence — it's an LSP (Language Server Protocol) client, the same protocol VSCode and, for JS/TS, WebStorm ultimately talk to underneath their own tooling.

Extensions — compiled to WebAssembly, sandboxed.

The trade-off is real in both directions: WASM's sandbox is why Zed's extension marketplace is smaller — some things Node's ecosystem makes trivial are genuinely harder to express safely in a sandboxed WASM API.

AI features sit on the same buffer model as everything else.

• Edit predictions and agent-driven changes apply as incremental operations on the Rope/CRDT buffer — the same primitive a human keystroke or a collaborator's edit uses — not a full-file string replace.
• That's why streamed AI edits can land while you keep typing elsewhere in the file without the two streams clobbering each other: it's the exact conflict model built for multiplayer, reused for "you and the model editing concurrently."
• Parallel agents (2026) extend this the same way multiplayer does — multiple concurrent operation streams, one buffer, one merge model.

Process model, side by side.

VSCode's model, in more detail.

• Main process (Electron/Node) owns app lifecycle and windows; a renderer process (Chromium) draws the actual UI as a web page — real DOM, real CSS layout, a real browser paint/composite pipeline doing the work of displaying text.
• The extension host runs as its own Node.js process specifically so a slow extension can't block the UI thread — this separation was added after early VSCode versions ran extensions in-process and paid for it in jank.
• The genuine strength this buys: any npm package is a viable extension dependency, which is a huge reason VSCode's marketplace dwarfs everyone else's.

WebStorm's model, in more detail.

• Built on the IntelliJ Platform (JVM). On opening a project, it builds PSI (Program Structure Interface) — a full semantic tree of the codebase, not just syntax — which is why indexing takes a visible moment on a large project.
• That upfront index is exactly what powers WebStorm's deepest party trick: instant, whole-project "Find Usages," safe rename, and structural refactors that don't rely on a language server answering fast enough on demand.
• The cost is memory and startup: a JVM heap sized to hold that index, and a GC that has to manage it. Recent IntelliJ Platform versions have pushed real rendering improvements, but the core model — JVM process, semantic index in memory — hasn't changed.

Rendering pipeline, compared.

Every one of these can render text correctly. The difference shows up in how many general-purpose layers sit between a keystroke and the pixel changing.

Where Rust's ownership model pays off concretely.

• No garbage-collector pause stalling a keystroke mid-frame — memory is freed deterministically as values go out of scope, not on a GC's own schedule.
• Data races caught at compile time — this matters most exactly where it's hardest to get right by hand: a multiplayer buffer being mutated by your keystrokes, a collaborator's edits, and a streaming AI response, all at once.
• This is a genuine language-level advantage, not marketing — it's also why a Rust rewrite is a multi-year bet, and why most editors don't attempt it.

Keeping the UI thread free.

GPUI runs on an async executor: LSP requests, file I/O, git status, and AI calls all get pushed to background tasks, with only the result posted back to update the UI. The rendering thread's job stays narrow — draw the current state — instead of also waiting on a language server or a network call.

The full comparison, in one table.

Why any of this matters day to day.

• Latency you can't measure but immediately feel every time you type is the Rope + GPUI stack, not a coincidence.
• A pairing session that never says "please wait, syncing" is the CRDT layer, not luck.
• A laptop that runs cooler with the editor open all day is fewer processes doing overlapping work, not a fluke.
• An AI suggestion streaming in without stomping what you're typing next to it is the same conflict-merge model multiplayer uses.

None of this requires knowing any of the above to benefit from it — but knowing it is why the trade-offs on the honest-caveats slide are worth accepting for what you get back.

That's the mechanism. Go feel it.

Benchmarks and architecture diagrams only go so far — the honest test is opening your own real project and typing in it for a week.