Zed

Zed is a next-generation code editor engineered for speed and collaboration, written entirely in Rust by the team behind Atom and Tree-sitter. It combines GPU-accelerated rendering through its custom GPUI framework with a deeply integrated language server and AI subsystem, making it one of the most technically ambitious open source editors in existence.

At its core, Zed treats multiplayer editing as a first-class feature: multiple developers can share a project session with live cursors, shared selections, and real-time edits over an encrypted WebSocket connection to Zed’s collab backend. The editor leverages Tree-sitter for structural code understanding, enabling features like syntax-aware selection, precise code navigation, and accurate syntax highlighting across hundreds of languages.

Zed’s AI integration goes well beyond autocomplete. The built-in Agent panel supports multiple LLM providers (Anthropic, OpenAI, Bedrock, Ollama, and more) and fully implements the Model Context Protocol (MCP), allowing external tools to extend the agent’s capabilities. Version 1.0 shipped in April 2026, marking Zed’s arrival as a production-ready editor.

The extension ecosystem uses WebAssembly via wasmtime to sandbox third-party language and tool integrations safely. With 235+ crates organized in a disciplined Rust workspace, Zed is architected to evolve without sacrificing the performance characteristics that distinguish it from Electron-based alternatives.

What You Get

• GPU-Accelerated Rendering via GPUI - A custom Rust UI framework drives all rendering with the GPU, delivering consistently low frame times even with large files and complex syntax highlighting.
• Real-Time Multiplayer Editing - Multiple developers can join the same project session with live cursors, shared selections, and synchronized edits transmitted over an encrypted WebSocket connection.
• Built-In AI Agent Panel - A fully integrated agent panel supports Anthropic, OpenAI, Bedrock, Ollama, DeepSeek, Codestral, X.AI, and OpenAI-compatible providers, with Model Context Protocol (MCP) server support for custom tooling.
• Tree-sitter-Powered Language Intelligence - Structural code parsing enables accurate syntax highlighting, semantic token navigation, symbol outlines, and context-aware refactoring across hundreds of languages.
• WebAssembly Extension System - Third-party language servers, themes, and tool integrations run inside a wasmtime sandbox, ensuring extensions cannot destabilize the editor.
• Integrated Debugger - A full Debug Adapter Protocol (DAP) client is built into the editor, supporting breakpoints, call stacks, watch expressions, and REPL evaluation without external plugins.
• Native Git Integration - A dedicated Git panel shows diffs, branch history, staging, commits, and inline conflict resolution, with a branch diff view that can send changes directly to the AI agent for review.
• Remote Development via SSH - Connect to and edit files on remote servers over SSH with full LSP support, eliminating the need for a separate remote extension.

Common Use Cases

• Remote pair programming - Two engineers share a Zed session over the internet, editing the same Rust service with live cursors, AI suggestions, and shared terminal access without any screen-sharing latency.
• AI-augmented code review - A developer sends an entire branch diff to the built-in agent panel for review, receives inline suggested edits, and accepts or rejects changes without leaving the editor.
• Large monorepo navigation - An engineer working in a 200-crate Rust workspace uses Tree-sitter symbol search and project-wide diagnostics to jump between definitions and find callers in milliseconds.
• Remote server editing - A DevOps engineer connects to a production-adjacent staging server via SSH, edits configuration files with full language server support, and sees diagnostics inline as they type.
• Polyglot team workflows - A team working across TypeScript, Python, and Go uses Zed’s per-language LSP adapters, unified settings, and shared extension registry to maintain consistent tooling regardless of language.
• Performance-sensitive local development - A developer on older hardware uses Zed’s native Rust binary to run a full-featured editor with minimal memory and CPU overhead, keeping the rest of the machine available for build processes.

Under The Hood

Architecture Zed is structured as a disciplined Rust workspace of over 235 crates, each representing a bounded context such as the editor engine, collaboration server, AI agent, debugger, extension host, or git integration. The custom GPUI framework acts as the foundational layer, providing a retained-mode, GPU-driven scene graph with platform-native backends for macOS, Linux, and Windows. Async communication between subsystems flows through smol tasks and tokio threads, with entities communicating via typed channels and event subscriptions rather than shared mutable state. The collaboration backend is a separate Axum-based service that manages room state, real-time buffer synchronization, and user presence over WebSocket connections; the client maintains a layered RPC stack that decouples local-first responsiveness from network availability. Extensions run inside a wasmtime sandbox with a versioned WASI API, preventing third-party code from affecting editor stability.

Tech Stack The editor is written in Rust with a Cargo workspace resolver configured for maximum parallel compilation. GPUI provides the cross-platform rendering pipeline, drawing to Metal on macOS, Vulkan/OpenGL on Linux, and Direct3D on Windows. Async I/O uses a hybrid of smol for GPUI tasks and tokio (via gpui_tokio) for network-heavy operations. The collaboration server runs on Axum with SeaORM for persistent state and PostgreSQL in production. Tree-sitter provides incremental, error-tolerant parsing for language intelligence. wasmtime and wasmtime-wasi execute extension WebAssembly. LLM integrations span the Anthropic, OpenAI, Bedrock, DeepSeek, Codestral, X.AI, Copilot, and Ollama APIs, all abstracted behind a common provider trait. LiveKit handles real-time audio and video for voice channels.

Code Quality The test suite is extensive and architecturally sophisticated. The editor crate alone ships dedicated test modules for keybindings, code completion, edit predictions, block comments, and Vim compatibility, with a NeovimBackedTestContext that runs assertions against a live Neovim process to verify behavioral parity. GPUI provides a deterministic test harness that simulates async task execution, enabling reproducible tests for complex interaction sequences without real timers or I/O. Error handling uses explicit Result and anyhow::Error propagation throughout, with structured logging via zlog and distributed tracing support. The workspace enforces clippy, rustfmt, typos, and cargo-about license compliance in CI, and renovate.json automates dependency updates.

What Makes It Unique Zed’s most technically distinctive contribution is GPUI, a production-grade, GPU-first UI framework for Rust that is published independently under Apache 2.0 and used to build the entire editor. Unlike toolkits that adapt web or game rendering pipelines, GPUI is purpose-built for the demands of a code editor: glyph-level text layout, sub-pixel antialiasing, and deterministic layout calculations at 120 FPS. The native Tree-sitter integration treats the syntax tree as a first-class runtime data structure rather than a post-hoc highlight source, enabling structural selection, precise folding, and query-driven language features. The built-in agent panel with full MCP support places Zed ahead of most editors in AI integration depth, allowing the agent to invoke registered tools (including custom server tools), run terminal commands, and apply multi-file diffs within a single conversation thread.

Self-Hosting

Zed’s source code is dual-licensed: the core editor and most crates are released under GPL-3.0-or-later, while the GPUI framework and certain utility crates are licensed under Apache-2.0. For self-hosting purposes this means the editor binaries and collaboration server are copyleft: you can run them internally, modify the code, and even distribute modified versions, but any distributed form must carry the GPL-3.0 license and make source available to recipients. The Apache-2.0 components (GPUI) are more permissive and can be embedded in proprietary software without copyleft obligations.

Running Zed’s collaboration backend yourself requires standing up the collab service — an Axum-based Rust binary — alongside a PostgreSQL database, a LiveKit server for audio/video, and object storage compatible with MinIO’s S3 API for blob data. The stack is containerized via Docker Compose for local development but you will need to provision and operate these services in production, handle TLS termination, manage database migrations via SeaORM, and configure environment variables for secrets and LLM API keys. This is a non-trivial operational footprint compared to simply downloading the Zed desktop app and signing into zed.dev.

Zed Industries operates a managed cloud service at zed.dev that handles all collaboration infrastructure, account management, and LLM token proxying. Self-hosters give up this hosted backend — meaning multiplayer sessions, shared channels, and the managed LLM proxy require running your own collab server — and also forego automatic editor updates, official support channels, and any hosted AI credits. There is currently no paid enterprise tier with SLAs or dedicated support; the managed service is free for individuals and teams as Zed Industries grows its user base.