Get AI summaries of any video or article — Sign up free
Zed, Vim, And The Problem Of Editors thumbnail

Zed, Vim, And The Problem Of Editors

The PrimeTime·
5 min read

Based on The PrimeTime's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Zed’s Vim mode targets practical compatibility while respecting Zed’s multiplayer-first architecture, so it doesn’t aim for full Neovim parity.

Briefing

Zed’s Vim mode is being built not as a compatibility layer for Neovim, but as a feature set that fits Zed’s own architecture—especially its multiplayer-first data model. Thorston, now at Zed after work at Sourcegraph, describes how the editor’s core concepts (buffers, CRDTs, and rendering loops) force trade-offs: some Vim behaviors can be approximated, but others—like Vim’s hidden buffers, command-line piping, and keystroke-level macros—don’t map cleanly onto Zed’s action/binding system.

The practical result is a “merge what matters” approach. Zed’s Vim mode is implemented as a single Rust crate, and development has focused on closing the gaps users notice most: motions that take counts (for example, variants of “z z” behavior), dot-repeat support, visual-mode indentation edge cases, and missing registers/marks. The team also uses Neovim’s headless mode as a reference for golden tests: simulated keystrokes run in Neovim to produce expected cursor/selection outcomes, then the same keystrokes are replayed in Zed and outputs are compared. That testing strategy is meant to keep the experience close where it counts, even while the underlying mechanics differ.

Beyond Vim compatibility, the conversation connects editor design to the realities of developer tooling at scale. Thorston frames developer tools as a place where engineering can directly move the needle—unlike many B2C products where marketing can dominate. He also emphasizes that “APIs” in developer tools aren’t just network interfaces; they include CLI flags, settings schemas, and editor configuration formats. In that mindset, editor features become contracts with strong user opinions, which explains why text editors generate intense loyalty and backlash when behavior changes.

Linux support becomes another lens on the same theme: the experience is “pretty good” on Wayland, but X11 performance work is tricky and may require changes to Zed’s event loop. The Linux port also faces fragmentation—different windowing stacks, legacy X11 layers, and desktop environments with their own rules for window decorations. Collaboration features are still incomplete on Linux, with audio/video and screen-sharing called out as especially hard.

Finally, the discussion highlights why editor features behave like a “fat tail”: small capabilities can be mission-critical for specific users. A ticket from GitHub cofounder Scott Shone about Vim replace modes (lowercase/uppercase “r”) drew a $500 bounty after community interest proved it wasn’t niche. Similar stories come up around built-in Git integration versus terminal workflows, showing that even when a feature is optional, enough users depend on it that missing it can feel like a deal-breaker.

Taken together, the interview paints editor development as a balancing act between architectural correctness, compatibility expectations, and platform constraints—where the hardest problems aren’t just rendering speed or keybindings, but the long list of “small” behaviors that determine whether a community feels at home or angry.

Cornell Notes

Zed’s Vim mode is built to fit Zed’s multiplayer-first architecture, so it aims for practical closeness rather than 100% Neovim compatibility. Thorston describes a Rust-based Vim mode crate, ongoing work to add missing motions, counts, dot-repeat, registers, and visual-mode correctness, and a testing approach that uses Neovim headless golden tests to compare cursor/selection results. Some Vim concepts don’t translate well—hidden buffers, command-line piping, and true keystroke macros—because Zed’s input becomes actions/bindings rather than raw keystrokes. The broader theme is that developer tools behave like contracts: settings schemas, CLI flags, and editor behaviors carry strong user opinions, and small feature gaps can trigger outsized backlash. Linux support adds another layer of complexity due to Wayland/X11 differences and desktop-environment constraints.

Why does Zed’s Vim mode avoid “drop-in Neovim compatibility,” and what architectural mismatch drives that decision?

Zed’s foundation is multiplayer-first, built around CRDTs and buffer/data structures needed for collaborative editing. That means Zed can’t simply embed Neovim and inherit Vim’s internal model. Thorston points to concrete mismatches: Zed’s buffer/window behavior is tied to UI elements like the tab bar, while Vim separates buffers from how they’re displayed (including hidden buffers across windows). Zed also treats colon commands as a UI command palette rather than Vim’s command-line environment where piping and shell integration are fundamental. Finally, Vim macros rely on recording raw keystrokes into registers; Zed’s platform input is converted into actions/bindings earlier in the pipeline, so replaying keystrokes requires a different mechanism.

Which Vim behaviors are being prioritized in Zed’s Vim mode, and how does the team verify correctness?

The work focuses on the motions and edge cases users notice: count-aware motions (e.g., variants of “z z” that center a counted line), dot-repeat support so repeated edits behave like Vim, and visual-mode indentation behavior that previously moved the cursor incorrectly. Thorston also mentions adding registers and marks over time, with limitations tied to Vim’s memory model. Verification uses Neovim headless tests: simulated keystrokes run in embedded Neovim to generate “golden” expected outputs (cursor position/selection), then the same keystrokes are replayed in Zed and results are compared.

What are examples of Vim features that don’t map cleanly onto Zed’s model?

Hidden buffers are one example: Vim can keep buffers open but not visible in certain windows, while Zed’s UI ties open buffers to the tab bar, and closing removes them from the tab bar. Another is buffer/window lifecycle: when a view/window closes, Zed closes the buffer and prompts about discarding/saving, whereas Vim’s separation of buffer and window gives different semantics. Command-line piping is also difficult: Vim’s ex/command mode supports piping and shell round-trips (e.g., using exclamation-style commands), while Zed’s colon opens a command palette UI rather than a text-mode command pipeline. Macros are another: Vim records keystrokes into registers for later replay, but Zed’s input-to-action conversion prevents straightforward keystroke recording.

How does Linux fragmentation affect Zed’s development priorities?

Thorston describes X11 as legacy and performance-sensitive: improving X11 performance may require changing Zed’s event loop or main loop handling. Wayland performance is described as pretty good, and missing pieces include window decoration behaviors—GNOME’s expectations force Zed to supply its own decorations. Collaboration features are also incomplete on Linux, with audio/video and screen-sharing called out as particularly challenging. The overall theme is that Linux isn’t one environment; different windowing stacks and desktop policies create ongoing platform-specific work.

Why do “small” editor features create outsized community reactions?

Editor users often have strong, personal workflows, and the category has a long “fat tail” of must-have features. Thorston cites a case where Scott Shone (GitHub cofounder) requested Vim replace-mode behavior (lowercase/uppercase “r”) and a $500 bounty followed after community validation. The point isn’t that everyone needs it, but that enough people do that missing it feels unacceptable. Similar dynamics show up with built-in Git support versus terminal workflows: some users can live without it, while others treat it as essential.

Review Questions

  1. Which parts of Vim’s behavior are easiest to replicate in Zed’s Vim mode, and which are fundamentally constrained by Zed’s multiplayer/CRDT architecture?
  2. How do Neovim headless golden tests help Zed’s Vim mode development, and what kinds of outputs are compared?
  3. What Linux-specific factors (Wayland vs X11, window decorations, event loops, collaboration) most influence Zed’s release priorities?

Key Points

  1. 1

    Zed’s Vim mode targets practical compatibility while respecting Zed’s multiplayer-first architecture, so it doesn’t aim for full Neovim parity.

  2. 2

    Zed’s Vim mode is implemented as a single Rust crate, with ongoing work on motions, counts, dot-repeat, and visual-mode correctness.

  3. 3

    Neovim headless golden tests are used to validate Vim-mode behavior by comparing cursor/selection outcomes after simulated keystrokes.

  4. 4

    Some Vim concepts—hidden buffers, command-line piping, and keystroke-level macros—don’t translate cleanly because Zed’s UI and input pipeline differ.

  5. 5

    Linux support is constrained by Wayland/X11 differences, desktop-environment window decoration rules, and performance-sensitive event-loop decisions.

  6. 6

    Editor features behave like contracts with users: even niche capabilities can become high-priority when enough people depend on them (e.g., Vim replace-mode “r” with a $500 bounty).

Highlights

Zed’s Vim mode is built around Zed’s CRDT/buffer model, so compatibility is selective: motions and repeats get close, but hidden buffers and true keystroke macros don’t map cleanly.
Golden testing uses Neovim headless runs to generate expected outputs, then compares them against Zed after replaying the same keystrokes.
X11 performance work may require event-loop changes, while Wayland performance is already described as pretty good.
A Scott Shone request for Vim replace-mode behavior triggered a $500 bounty after community disagreement resolved into real demand.

Topics

Mentioned