Lore

A timeline of how the Zed codebase came to be what it is. Dates are derived from git history; finer-grained "why" is paraphrased from commit messages, blog posts, and code archaeology. Where commits are silent on intent, hedging language is used.

Eras

The founding (Feb 2021 – 2022)

The first commit lands on Feb 20, 2021 (b400449a58). The team — many of them ex-Atom — start a new editor in Rust with a homegrown UI framework rather than Electron. The early codebase establishes the foundational primitives that survive to this day:

• GPUI as the UI runtime, built around Entity<T> handles and a single foreground thread.
• Rope + sum_tree + text as the data structures backing buffers.
• Worktree + Project + Editor as the layering that maps "open a folder" to "edit a file".

The early Zed binary targets macOS only; Linux and Windows backends come later.

Multiplayer first (2022 – 2023)

Long before Zed was public, multiplayer collaboration was a first-class concern. The CRDT-flavored buffer model in crates/text, the protobuf RPC stack in crates/proto + crates/rpc, and the crates/collab backend all date from this era. The premise — pair-programming should be as easy as joining a Google Doc — drove design choices that still constrain the architecture today (e.g. every editor operation has a CRDT-friendly representation).

Open source launch (Mar 2023 – Jan 2024)

Zed goes open-source in March 2023 with the initial public release of the Mac client. The repo's commit volume and contributor count rise sharply. License files (LICENSE-AGPL, LICENSE-GPL, LICENSE-APACHE) are added; cargo-about dependency vetting is wired up via script/check-licenses and script/licenses/zed-licenses.toml.

Linux and Windows ports (2024)

The gpui_linux and gpui_windows crates — and the platform-agnostic gpui_platform shared layer — are stood up in 2024. WGPU becomes the cross-platform rendering backend (gpui_wgpu), gradually replacing platform-native paths. The first preview Linux builds appear, followed by Windows previews. Per-platform packaging scripts (script/bundle-linux, script/bundle-windows.ps1, script/flatpak, script/freebsd) accumulate.

The AI era (2024 – present)

Two waves of AI features land:

1. Edit prediction. The edit_prediction* crates appear (eight of them: edit_prediction, edit_prediction_cli, edit_prediction_context, edit_prediction_metrics, edit_prediction_types, edit_prediction_ui). The first-party model is "Zeta"; its prompting lives in crates/zeta_prompt.
2. The agent. crates/agent and crates/agent_ui — now the second- and fourth-largest crates by LOC — implement a tool-using coding agent. The Agent Client Protocol (ACP) is added in crates/acp_thread and crates/acp_tools, letting external agent backends drive the same UI. crates/agent_servers wires up Codex, Gemini CLI, OpenCode, and other external agents.

A wide menu of language-model providers gets added: anthropic, open_ai, google_ai, bedrock, ollama, mistral, deepseek, open_router, codestral, lmstudio, x_ai, plus Zed's own language_models_cloud gateway.

The platform years (2025 – 2026)

Recent work expands surface area:

• Debugger. The dap, dap_adapters, and debugger_ui crates implement a full DAP client and per-language adapters (March 2025 onward).
• Remote development. remote, remote_connection, and remote_server formalise headless-server editing.
• Settings UI. A graphical settings surface (crates/settings_ui) is added on top of the JSON store.
• Onboarding. crates/onboarding, crates/ai_onboarding, crates/language_onboarding polish first-run flows.
• Extension cleanups. The runtime is split into extension, extension_host, extension_api, with first-party extensions/ for proto/html/glsl.
• Telemetry & crashes. crates/telemetry, crates/telemetry_events, crates/crashes, plus Sentry integration in script/sentry-fetch and .factory/prompts/crash/.

The most recent commits at the time of this snapshot include Support latest MCP protocol version (#54494), Improve bare repo support (#55153), Use embedded bitmaps in fonts on Linux (#55202), and Rust 1.95 (#55104).

Longest-standing features

• Buffers, ropes, sum-trees. crates/rope and crates/sum_tree have weathered the entire history of the project.
• GPUI's entity model. The Entity<T> / Context<T> / cx.notify() pattern dates from the founding era and is still the central concurrency story.
• Multiplayer CRDT. crates/text and the replica-id machinery have survived multiple refactors and remain the basis for both local edits and remote collaboration.

Deprecated and removed features

Tracking deprecations precisely from commit messages alone is fuzzy, but a few patterns are visible:

• mod.rs files — the project deliberately moved away from src/foo/mod.rs to src/foo.rs. The convention is documented in .rules.
• Direct cargo clippy invocation — replaced by ./script/clippy to set workspace flags consistently.
• The "v0" provider — removed in Remove v0 provider (#55177). Likely an early language-model provider that has been superseded.
• Streaming-edit feature flag — removed in agent: Remove streaming edit feature flag (#55152). The feature graduated from flag to default.
• Release retagging in CI — removed in ci: Remove release retagging support (#55199).

Major rewrites

• GPUI 2. The codebase carries scars from a gpui → gpui2 rewrite (the gpui_macros derive crate, the Element/Render trait redesign). The legacy paths have been pruned.
• Cross-platform rendering. Migration from per-platform graphics stacks to gpui_wgpu for shared rendering.
• Extension host. Originally one crate, split into extension / extension_host / extension_api to separate the WASM runtime from the protocol surface.
• Settings stack. A separation into settings, settings_content, settings_json, settings_macros, settings_ui gives the JSON config a typed, schema-driven foundation.

Growth trajectory

The crate count keeps climbing: 231 workspace members at the time of this wiki, with new ones added near-weekly. Recent additions cluster around AI (acp_thread, acp_tools, agent_servers, language_models_cloud, cloud_llm_client), debugger (dap, dap_adapters, debugger_tools, debugger_ui), and platform refactors (gpui_platform, gpui_shared_string, gpui_tokio, gpui_util, gpui_web, gpui_wgpu).