Zed is a high-performance code editor developed by the creators of Atom and Tree-sitter, built from scratch in Rust to deliver blazing-fast editing and seamless multiplayer collaboration. It targets developers and teams frustrated with sluggish editors, offering real-time shared editing, AI-assisted coding, and low-latency performance across macOS, Linux, and Windows.
Technically, Zed leverages Tree-sitter for parsing, GPU-accelerated rendering via GPUI, and a modular architecture designed for extensibility. It supports package managers on all major platforms and is actively developed by Zed Industries, Inc., with open-source contributions encouraged under an open license framework managed by cargo-about.
What You Get
- GPU-Accelerated Rendering - Zed uses GPUI to render text and UI with the GPU, enabling smooth scrolling and responsiveness even with large files.
- Real-Time Multiplayer Editing - Multiple developers can edit the same file simultaneously with live cursor tracking and shared selection states.
- Integrated LLM Support - AI tools are natively integrated to generate, refactor, and explain code without leaving the editor.
- Tree-sitter Integration - Uses Tree-sitter for accurate syntax parsing, enabling advanced features like precise code navigation and refactoring.
- Cross-Platform Native Support - Official builds available for macOS, Linux, and Windows with native package manager support (Homebrew, apt, winget).
- Low-Latency Performance - Written in Rust to efficiently utilize multiple CPU cores and minimize memory overhead for fast startup and responsiveness.
Common Use Cases
- Pair programming remotely - Two developers collaborate in real time on a Rust service, sharing edits, navigating symbols, and using AI suggestions simultaneously.
- Large codebase navigation - A senior engineer works with a 50k-line TypeScript codebase and relies on Zed’s Tree-sitter-powered symbol navigation to jump between files instantly.
- AI-assisted refactoring - A team uses Zed’s integrated LLM to automatically convert legacy code patterns and generate unit tests without switching tools.
- High-performance development on low-end hardware - A developer on an older laptop uses Zed’s Rust-based architecture to maintain snappy performance where VS Code lags.
Under The Hood
Architecture
- Modular monorepo organized into 80+ crates with clear bounded contexts such as UI, language server protocol, and real-time collaboration
- Trait-based dependency injection enables loose coupling between components like HTTP clients and clock services
- Event-driven communication via async channels and streams decouples editor, diagnostics, and language server systems
- Platform abstraction layers isolate rendering and input logic across macOS, Windows, and Linux while maintaining UI consistency
- Extension system supports dynamic plugin loading with versioned, safe APIs for third-party tooling
- Layered RPC stack over WebSocket connects cloud services while preserving local-first UI responsiveness
Tech Stack
- Rust as the core language with a Cargo-based workspace, featuring a custom GUI framework (GPUI) and async runtime (smol)
- GPUI provides cross-platform rendering with native backends and WebAssembly support for web-based components
- MinIO and LiveKit handle blob storage and real-time media, orchestrated via Docker Compose
- WASM and wasmtime enable secure, sandboxed execution of extensions and web integrations
- Comprehensive tooling chain includes clippy, rustfmt, typos, and renovate for consistent code quality and dependency hygiene
- Protocol buffers and gRPC-style RPCs underpin inter-crates communication with pervasive async/await patterns
Code Quality
- Extensive test suite with domain-specific frameworks to validate async behavior, editor state, and Vim semantics under deterministic conditions
- Clear separation of concerns across core engine, language tools, and editor features, each in dedicated, focused crates
- Strong type safety enforced via Rust’s type system, with Arc for shared state and serde_json for structured serialization
- JSON-based state snapshots enable precise regression testing of complex user interactions like keybindings and text manipulation
- Explicit error handling through Result and Option ensures robustness without exceptions
- Strict linting and formatting rules maintain high code standards across the entire codebase
What Makes It Unique
- Built-in telemetry system with checksum validation and Kinesis integration, eliminating external analytics dependencies
- Custom Rust GUI framework (GPUI) with type-safe, extensible components like PopoverMenuHandle that enable dynamic UI composition
- Runtime menu building via Rc<RefCell<Option<Entity<M>>>> allows flexible, template-free UI element composition
- Position-aware toggle buttons that auto-adapt styling based on visual context for enhanced UI cohesion
- Tight integration of telemetry, crash reporting, and cloud infrastructure into a unified observability pipeline
- Lightweight API integrity checks using custom header parsing and hex-encoded checksums, avoiding heavy authentication overhead