Zed

Zed implements a custom immediate-mode UI framework (GPUI) written in Rust that directly manages GPU rendering, element layout, and event dispatch without relying on web technologies or platform-specific UI toolkits. The framework uses a reactive entity-component system where UI state changes trigger re-renders through a display map pipeline that computes layout, paint, and hit-testing in a single pass. This enables sub-millisecond frame times and pixel-perfect control over rendering behavior across macOS, Linux, and Windows.

Zed integrates LSP servers for semantic analysis (diagnostics, completions, definitions, refactoring) while using tree-sitter for fast, incremental syntax tree parsing across 40+ languages. The Project entity coordinates LSP lifecycle (spawn, shutdown, restart on config change) and maintains a Worktree abstraction that maps file system changes to LSP document synchronization. Tree-sitter provides real-time syntax highlighting and structural awareness without waiting for LSP responses, enabling instant visual feedback.

Zed organizes editing surfaces into a Workspace entity containing multiple Panes arranged in a tree structure (split horizontally/vertically). Each Pane can contain multiple tabs (files or views), and the active tab is rendered. The workspace layout is persisted to disk and restored on editor restart, maintaining the user's editing context. The Pane system supports drag-and-drop tab movement and dynamic pane creation/destruction.

Zed uses a SettingsStore that manages configuration through hierarchical layers (system defaults, user settings, workspace settings, project settings). Settings are stored in JSON or TOML files and merged with precedence rules (project > workspace > user > system). The system supports hot reload: changes to settings files are detected and applied immediately without editor restart. Settings can be edited via UI or by directly editing configuration files.

Zed provides a theme system that defines colors, fonts, and UI styling through JSON configuration files. Themes can be selected from a built-in library or created custom. The system supports live preview: changing theme settings immediately updates the editor UI without restart. Themes are composable, allowing users to extend built-in themes with custom overrides. The theme system integrates with syntax highlighting to provide language-specific color schemes.

Zed's text editor uses a Display Map pipeline that transforms the raw buffer into a renderable display through multiple stages: soft-wrapping, folding, and viewport clipping. The pipeline is lazy and incremental: only visible lines are computed, and changes to the buffer trigger minimal re-computation. The system uses a rope data structure for efficient buffer operations and a segment tree for tracking display map state. This architecture enables responsive editing even in very large files (100k+ lines).

Zed's buffer system maintains the current text content, undo/redo stacks, and change history using a persistent data structure (likely a rope or B-tree). Each edit operation is recorded with metadata (timestamp, author, change type) enabling undo/redo and collaborative conflict resolution. The system supports grouped edits (multiple edits treated as a single undo step) and change tracking for diff computation. Buffers are associated with files and maintain dirty state for unsaved changes.

Zed's search system provides find-in-file and find-in-project capabilities with regex support, case sensitivity options, and whole-word matching. Results are computed incrementally as the user types, with a result counter and navigation controls (next/previous match). The find-replace feature allows batch replacement with preview. Search results are highlighted in the editor with a distinct color, and the editor automatically scrolls to show the current match.

Zed includes a command palette (accessed via Ctrl+Shift+P) that provides fuzzy search over all available commands, keybindings, and actions. The palette displays matching commands with their keybindings, allowing users to discover and execute commands without memorizing keybindings. The fuzzy search algorithm matches partial strings and ranks results by relevance. Commands can be registered by extensions or core editor features.

Zed's collaboration system uses a custom protocol (ACP — Agent Communication Protocol) to synchronize edits across multiple clients connected to a central server. Each client maintains a local buffer with version vectors, and edits are transformed against concurrent changes using an operational transformation approach that preserves causal ordering. The system handles network partitions, reconnection, and out-of-order message delivery through a hybrid CRDT-like mechanism that assigns unique client IDs and timestamps to resolve conflicts deterministically.

Zed includes a built-in AI agent panel that can spawn multiple concurrent agent threads, each capable of calling tools (file read/write, terminal execution, git operations) and invoking language models from multiple providers (OpenAI, Anthropic, Zed Cloud). The Agent Panel UI manages thread lifecycle, displays agent reasoning steps, and allows users to mention files/symbols as context. The system uses a mention system to inject codebase context into prompts and supports subagent spawning for hierarchical task decomposition.

Zed implements an edit prediction system (codenamed Zeta) that speculatively renders predicted text changes before the LSP server responds, reducing perceived keystroke latency. The system uses local heuristics and lightweight models to predict the most likely next edit (e.g., auto-closing brackets, indentation) and immediately renders it, then reconciles with the actual LSP response when it arrives. This creates the illusion of zero-latency editing even when LSP servers are slow.

Zed provides first-class support for Vim and Helix keybindings through a modal editing system that switches between normal, insert, and visual modes. The implementation uses a keybinding dispatch system that interprets sequences of keypresses as commands (e.g., 'dd' for delete line, 'ciw' for change inner word) and applies them to the buffer. The system integrates with tree-sitter to provide structural awareness for motions (e.g., 'dap' deletes a paragraph).

Zed includes a built-in debugger that communicates with language-specific debug adapters via the Debug Adapter Protocol (DAP). The debugger panel displays stack traces, variables, watches, and breakpoints, and allows stepping through code (step-in, step-over, step-out). Breakpoints are persisted in the workspace and can be set by clicking the gutter or via command palette. The system handles breakpoint synchronization with the debug adapter and supports conditional breakpoints and logpoints.

Zed integrates Git operations through a Git panel that displays file status, diffs, and staging controls. The system uses a GitStore abstraction that maintains the current branch, staged/unstaged changes, and commit history. Users can stage/unstage individual files or hunks, view diffs side-by-side, and switch branches from the UI. The diff system uses tree-sitter to provide structural highlighting of changes, making it easier to understand code modifications.

Zed includes an integrated terminal panel that allows running shell commands and viewing output without leaving the editor. The system also supports Jupyter REPL integration for interactive notebook-style development in Python and other languages. Terminal sessions are tied to the workspace and can be spawned/closed via UI or commands. Output is syntax-highlighted based on language detection.

Zed supports extensions written in WebAssembly (WASM) that run in a sandboxed environment isolated from the main editor process. Extensions can hook into editor events, register commands, and access a limited API for file operations and UI manipulation. The extension host manages the WASM runtime, lifecycle, and communication with the editor via message passing. This approach provides security and stability while allowing community extensions.