Zed
High-performance multiplayer code editor
Zed — Official Website
Quick Take: Zed
Zed is the fastest graphical code editor available, and it's not close. If you've been frustrated by VS Code's memory usage, startup time, or rendering jank, Zed is the editor you've been waiting for. The Tree-sitter integration, Vim mode, and real-time collaboration are genuinely excellent. The AI assistant works well with bring-your-own-key flexibility. The honest limitation is the extension ecosystem—if you depend on VS Code extensions for niche languages or specialized workflows, you'll hit gaps. But for TypeScript, Python, Rust, Go, and web development, Zed has everything you need and runs circles around VS Code on performance.
Best For
- •Developers Who Prioritize Editor Speed and Low Resource Usage
- •Teams That Want Built-In Real-Time Collaboration
- •Vim Users Who Want a Fast Graphical Editor
What is Zed?
Zed is a code editor written in Rust by the people who created Atom. Nathan Sobo, Max Brunsfeld (creator of Tree-sitter), and Antonio Scandurra spent years at GitHub building Atom, watched it lose to VS Code, and started over with a clear thesis: an editor should be fast, multiplayer, and AI-native from the ground up. Zed is the result. The speed difference is the first thing you notice. Zed opens a project in under 200ms. Scrolling through a 10,000-line file is instant—no lag, no jank, no flash of blank content while the renderer catches up. This is because Zed uses GPUI, a custom GPU-accelerated UI framework the team built from scratch in Rust. Everything—the file tree, the editor panes, the terminal, the command palette—renders via Metal on macOS. Memory usage sits at 80-150MB for a typical project, compared to VS Code's 300-600MB. The collaboration features are built into the core, not bolted on as an extension. Open a Zed channel, invite a teammate, and you're pair programming in real time—multiple cursors on the same file, voice chat, screen following. It's Google Docs-style collaboration for code, implemented at the editor level rather than through a screen share. Zed's AI integration includes inline completions (similar to Copilot), an AI assistant panel for conversational coding, and an agent that can make multi-file edits. You can use Zed's own AI service, bring your own OpenAI/Anthropic/Google API key, or connect a local model via Ollama. The free tier includes limited AI prompts; the $20/month Pro plan removes limits. The extension ecosystem is the honest weakness. As of early 2026, Zed has hundreds of extensions—not VS Code's tens of thousands. Language support for mainstream languages (TypeScript, Python, Rust, Go, C++) is excellent via Tree-sitter grammars and language servers. But niche languages, framework-specific tooling, and specialized workflows may not have extensions yet.
Install with Homebrew
brew install --cask zedDeep Dive: Why Zed Built Everything from Scratch
The technical decisions behind GPUI, Tree-sitter integration, and why the Atom team started over instead of forking VS Code.
History & Background
The Atom editor launched in 2014 and pioneered the idea of a hackable, web-based code editor. But Electron's performance ceiling (Atom was built on Electron before VS Code) meant Atom could never match native editors on speed. When GitHub discontinued Atom in 2022, Nathan Sobo, Max Brunsfeld, and Antonio Scandurra founded Zed Industries with a clear thesis: use Rust and GPU rendering to build what Atom should have been. They spent 2022-2023 in closed beta, refining the architecture. Zed went open-source in January 2024, and by mid-2024 had 30,000+ GitHub stars. The trajectory since has been steady growth, with AI integration becoming a major focus in 2025-2026.
How It Works
GPUI is the heart of Zed. It's a GPU-accelerated UI framework written in Rust that renders everything via Metal (macOS) or Vulkan (Linux). Text, UI elements, and editor content all go through the same GPU pipeline, eliminating the CPU rendering bottleneck that slows down Electron-based editors. Tree-sitter runs in-process for syntax analysis, incrementally updating the parse tree on every keystroke. Language servers (rust-analyzer, pyright, tsserver) run as separate processes communicating via LSP—same as VS Code, but with less overhead from the editor side. The collaboration system uses CRDTs (Conflict-free Replicated Data Types) for real-time editing, with Zed's servers handling signaling and peer-to-peer connections for data.
Ecosystem & Integrations
Zed's extension system uses WebAssembly for sandboxing and portability. Extensions can provide Tree-sitter grammars, language server configurations, themes, and slash commands for the AI assistant. The extension API is more constrained than VS Code's (you can't modify arbitrary UI elements), which limits flexibility but improves stability and security. The theme ecosystem is growing—popular themes (One Dark, Catppuccin, Dracula, Gruvbox, Nord) have Zed ports. Language extensions for Python, Rust, Go, TypeScript, Java, C/C++, and web frameworks are available and actively maintained.
Future Development
Zed's 2026 roadmap includes expanded debugger support (currently limited), deeper agent capabilities for the AI assistant, improved extension APIs for richer integrations, and stable Windows support. The team is also working on 'Zed Server'—a remote development mode similar to VS Code's Remote SSH, where the editor UI runs locally but the file system and language servers run on a remote machine. This is the biggest feature gap between Zed and VS Code, and addressing it would remove a major barrier to adoption for teams with remote development workflows.
Key Features
GPUI: Custom GPU-Accelerated UI
Zed doesn't use Electron, GTK, or any existing UI framework. The team built GPUI—a GPU-accelerated UI framework in Rust that renders the entire editor via Metal on macOS. This is why Zed feels instant: text rendering, syntax highlighting, the file tree, split panes, and even the command palette all render on the GPU. The result is consistent 120fps on ProMotion displays, zero-latency scrolling, and an editor that uses less memory than a single VS Code extension host process. GPUI is open-source and could theoretically be used by other projects, though Zed is its primary consumer.
Tree-sitter for Everything
Zed uses Tree-sitter (created by Zed co-founder Max Brunsfeld) for syntax highlighting, code folding, indentation, and structural navigation. Tree-sitter parses your code into a concrete syntax tree incrementally—every keystroke updates the tree in microseconds. This gives Zed syntactically-correct highlighting that works mid-edit (no flash of wrong colors while typing), accurate code folding that understands language structure, and structural selection (select the entire function, the entire if-block, the entire argument list with a keyboard shortcut).
Real-Time Collaboration
Zed's multiplayer features are built into the editor core. Create or join a channel, and you can co-edit files in real time—you see each other's cursors, selections, and edits instantly. Built-in voice chat means you don't need a separate Discord or Google Meet call. Screen following lets you follow a teammate's cursor as they navigate the codebase. This is pair programming without the screen-share lag. The collaboration works over Zed's servers (for signaling) with peer-to-peer connections for the actual editing data.
AI Assistant & Agent
Zed integrates AI at three levels. First: inline completions that predict the next few tokens as you type (similar to Copilot). Second: an AI assistant panel where you can ask questions about your code, request refactors, or generate new code with full file context. Third: an agent mode that can make multi-file edits across your project. You choose the model: Zed's bundled service, OpenAI (GPT-4o), Anthropic (Claude), Google (Gemini), or a local model via Ollama. The AI feels native rather than bolted on—completions appear inline, assistant responses stream into editor buffers.
Extensible via WebAssembly
Zed extensions run as WebAssembly modules, which means they're sandboxed, fast, and language-agnostic (write them in Rust, Go, C, or anything that compiles to WASM). Extensions can add language support (Tree-sitter grammars + language servers), themes, slash commands for the AI assistant, and more. The ecosystem is smaller than VS Code's (hundreds vs. tens of thousands) but growing steadily. Key extensions for Python, Go, Java, Docker, Tailwind CSS, and Prisma are available and well-maintained.
Vim Mode
Zed's Vim emulation is first-class—not a plugin, but a built-in mode you toggle in settings. It supports normal/insert/visual modes, motions (w, b, e, gg, G, %, f/t), text objects (iw, i", a{), registers, macros, marks, and most common Ex commands (:w, :q, :s). The Vim mode interoperates with Zed's native features: command palette, multi-cursor, AI completions, and collaboration all work while in Vim mode. For Vim users who want a graphical editor that doesn't fight their muscle memory, Zed's implementation is the best outside of Neovim itself.
Who Should Use Zed?
1The VS Code Refugee
A TypeScript developer has been using VS Code for 5 years. Their editor takes 3-4 seconds to start, uses 600MB of RAM, and occasionally hangs when loading a large monorepo. They install Zed and open the same project: it loads in 200ms, uses 120MB, and scrolling through any file is perfectly smooth. They install the Tailwind CSS extension for class name completions, set up their preferred keybindings, and configure the AI assistant with their Anthropic API key. The extension ecosystem doesn't have everything they used in VS Code, but the speed difference makes them willing to adapt.
2The Remote Pair Programmer
Two developers on different continents work together on a shared codebase. Previously they used VS Code Live Share, which had latency issues and occasionally desynced. In Zed, they join the same channel, open the project, and co-edit in real time with voice chat. One developer navigates to a bug, the other follows their cursor. They discuss the fix over voice, implement it together with simultaneous edits, and push the commit. The experience is closer to sitting next to each other than any screen-sharing tool.
3The Performance-Obsessed Rust Developer
A Rust developer uses rust-analyzer for LSP features and wants an editor that doesn't add overhead on top of the already-expensive rust-analyzer process. VS Code's Electron layer adds 400MB of overhead before rust-analyzer even starts. Zed runs the same rust-analyzer binary but with a fraction of the editor overhead, leaving more memory and CPU for compilation and analysis. The editor's native terminal lets them run `cargo build` without switching apps.
How to Install Zed on Mac
Zed is available as a direct download or via Homebrew. It requires macOS 12 (Monterey) or later.
Install via Homebrew
Run `brew install --cask zed` in your terminal. This installs the stable release to /Applications.
Install the CLI
Open Zed, press Cmd+Shift+P, and type 'cli: install'. This creates the `zed` command in /usr/local/bin, so you can open files and folders from the terminal with `zed .` or `zed myfile.ts`.
Configure settings.json
Press Cmd+Shift+P → 'zed: Open Settings'. Zed's settings are JSON. Set your theme (`"theme": "One Dark"`), font (`"buffer_font_family": "JetBrains Mono"`), font size (`"buffer_font_size": 14`), and enable Vim mode if you want it (`"vim_mode": true`). Settings take effect immediately on save.
Install Extensions
Open the Extensions panel (Cmd+Shift+X or via command palette). Install language extensions for your stack: Python, Go, Docker, Tailwind CSS, Prisma, etc. Each extension adds Tree-sitter grammar and/or language server support.
Pro Tips
- • Zed Preview (nightly) builds are available via `brew install --cask zed-preview` if you want to test new features early.
- • Your settings.json supports project-local overrides: create a .zed/settings.json in any project directory.
- • If you're coming from VS Code, install the 'VS Code Keymap' extension to keep familiar shortcuts.
Configuration Tips
Essential settings.json for Zed
Open settings (Cmd+Shift+P → 'zed: Open Settings') and start with: ```json { "theme": "One Dark", "buffer_font_family": "JetBrains Mono", "buffer_font_size": 14, "vim_mode": true, "format_on_save": "on", "autosave": { "after_delay": { "milliseconds": 1000 } }, "tab_size": 2, "soft_wrap": "editor_width" } ``` This gives you a productive baseline. Zed applies changes immediately when you save the settings file.
Set Up AI with Your Own API Key
In settings.json, add your preferred AI provider: ```json { "assistant": { "provider": { "name": "anthropic", "default_model": { "model": "claude-sonnet-4-20250514" } } } } ``` This gives you unlimited AI usage at your own API cost (typically $2-5/month for regular coding use). Works with OpenAI, Anthropic, Google, and Ollama for local models.
Alternatives to Zed
Zed competes with VS Code on capability and with Sublime Text on speed. Here's how they compare.
Visual Studio Code
Cursor
Sublime Text
Pricing
The Zed editor is free with all core features: editing, Tree-sitter, language servers, Vim mode, terminal, collaboration, and extensions. The free tier includes limited AI prompts per month (enough for occasional use) plus unlimited AI if you bring your own API key. The Pro plan ($20/month) removes AI prompt limits and includes priority support. There are no feature gates on the editor itself—every editing and collaboration feature is free.
Pros
- ✓Fastest editor available—200ms startup, 120fps scrolling, 80-150MB RAM
- ✓GPUI renders the entire UI on the GPU via Metal (not Electron)
- ✓Tree-sitter-powered syntax highlighting is accurate mid-edit
- ✓Real-time collaboration with voice chat built into the core
- ✓AI assistant supports OpenAI, Anthropic, Google, and local models via Ollama
- ✓First-class Vim mode built into the editor (not a plugin)
- ✓WebAssembly extension system is sandboxed and fast
- ✓Open-source (AGPL for editor, Apache 2.0 for GPUI)
Cons
- ✗Extension ecosystem is much smaller than VS Code's
- ✗Windows support is still in beta (macOS and Linux are stable)
- ✗No equivalent to VS Code's Remote SSH or Dev Containers
- ✗Some language servers (niche languages) don't have extensions yet
- ✗JSON-only settings with no GUI settings editor
- ✗Collaboration requires Zed's servers for signaling (can't self-host yet)
Community & Support
Zed's community is centered on GitHub (zed-industries/zed, 55,000+ stars), a Discord server, and the Zed blog. The core team is small but responsive—Nathan Sobo and other team members regularly participate in GitHub discussions and Discord. Development moves fast with multiple releases per week on the Preview channel. The extension ecosystem is growing as third-party developers build language support, themes, and integrations. The community tends toward developers who care about performance and are willing to trade VS Code's mature ecosystem for a faster, more focused editing experience.
Video Tutorials
Getting Started with Zed
More Tutorials
Zed is a great code editor, I am using it more and more these days #zed #coding #programming
Jeezy Codes • 16.7K views
There’s a fast new code editor in town
Fireship • 1.2M views
Zed Editor - Run Code Shorcut #zed #coding
Analyst's Corner • 40.6K views
Frequently Asked Questions about Zed
Our Verdict
Zed is the fastest graphical code editor available, and it's not close. If you've been frustrated by VS Code's memory usage, startup time, or rendering jank, Zed is the editor you've been waiting for. The Tree-sitter integration, Vim mode, and real-time collaboration are genuinely excellent. The AI assistant works well with bring-your-own-key flexibility. The honest limitation is the extension ecosystem—if you depend on VS Code extensions for niche languages or specialized workflows, you'll hit gaps. But for TypeScript, Python, Rust, Go, and web development, Zed has everything you need and runs circles around VS Code on performance.
About the Author
Related Technologies & Concepts
Related Topics
Sources & References
Fact-CheckedLast verified: Feb 23, 2026
- 1Zed Official Website
Accessed Feb 23, 2026
- 2Zed GitHub Repository
Accessed Feb 23, 2026
Research queries: Zed editor features 2026 Mac