Zed

Zed is a GPU-accelerated code editor built from scratch in Rust by the team that originally created GitHub's Atom editor. It renders at 120fps, starts nearly instantly, and keeps typing latency low enough that switching back to VS Code feels like moving through mud. The built-in AI assistant supports Claude, GPT-5, Gemini 3, and local models via Ollama, with an agentic mode that can autonomously explore your codebase, edit files, and surface diffs for review. Real-time multiplayer collaboration is built into the core, not bolted on. The Personal plan is free with 2,000 monthly edit predictions; the Pro plan at $10/month adds unlimited predictions and token credits. BYOK is supported on every tier. The extension ecosystem is still smaller than VS Code's, but for engineers who hit a performance wall, Zed offers a credible path that doesn't require sacrificing AI tooling.

There’s a moment, usually around day three of using Zed, where you open VS Code for something and it feels like the whole screen is fighting you. The boot lag, the frame stutter when scrolling a large file, the half-second between typing and seeing text. You’d stopped noticing those things. Zed made you notice them. Built in Rust by the engineers who shipped GitHub’s Atom, the Zed editor was designed from scratch around the premise that editor latency is a first-class concern, not a later optimization. The AI features came after that foundation was solid. That sequencing matters.

Quick verdict

Zed is the right editor for engineers who prioritize latency and want AI tooling that doesn’t require a separate subscription or a different editing paradigm. The extension ecosystem is the honest weakness. If your workflow depends on specific VS Code plugins, you’ll feel the gap. If it doesn’t, or if you’re willing to find out whether it does, Zed is a genuinely better daily experience for a large slice of developers.

What is Zed, exactly?

The founding story is worth knowing because it explains a lot of Zed’s design choices. Nathan Sobo and Antonio Scandurra built Atom at GitHub. Atom was beloved by developers for its extensibility but eventually lost the performance race to VS Code. When Microsoft acquired GitHub and eventually sunsetted Atom in 2022, the core team didn’t fold into a VS Code team. They went and started over, from scratch, with a different thesis: write the editor in Rust, render on the GPU, and treat performance not as a feature but as a constraint. Everything else gets designed around that constraint.

The result is an editor that opens in under a second on almost any machine, renders at 120fps, and keeps typing latency so low that the editor feels like it disappears. The Rust foundation isn’t a marketing angle. It’s why the editor can do things that Electron-based alternatives genuinely can’t do at the same frame budget.

AI landed as a layer on top of this. The inline assistant, the multi-model support, and the agentic editing mode are all real and functional, but the editor was never positioned primarily as an “AI coding tool.” That framing distinguishes it from Cursor or Windsurf, where the AI pitch leads everything. Zed’s pitch is that you’ll write faster and think more clearly because the editor gets out of your way. The AI is there when you need it, and it’s connected to the same infrastructure that powers multiplayer, which turns out to be a surprisingly good architecture for watching an agent work.

Zed Industries was founded in 2021, and the public release came in early 2024. It’s actively developed, open source on GitHub, and has a growing community that’s serious about keeping the performance bar high.

The features that earn Zed its dev following

Native performance you can feel

No benchmarks needed here. Open a 5,000-line file in Zed and in VS Code on the same machine and scroll fast. The difference is not subtle. Zed is GPU-accelerated, written to use multiple CPU cores efficiently, and renders without the overhead of a browser engine underneath it. The 120fps rendering means that changes from the AI agent, from a collaborator’s cursor, or from your own keystrokes appear without visible lag.

This matters more than it sounds in long sessions. Editor latency compounds. Every 40ms delay between keystroke and render is a small context break. Multiply that by hours of focused work and it adds up to mental friction. Zed removes most of it.

Startup time is also worth mentioning. On macOS, Zed opens in roughly 200-300ms on a modern machine. VS Code takes 2-4 seconds on the same machine with a typical extension setup. This is not a big deal when you open your editor once a day. It matters when you’re opening separate project windows frequently, or when you’ve gotten into the habit of closing and reopening to get a clean state.

Multibuffer for editing across files

Multibuffer is the feature that gets the least marketing attention but generates the most “wait, why doesn’t every editor do this” reactions. The idea is that you can compose excerpts from across your codebase into a single editable surface. Select a function definition from one file, the interface it implements from another, and the test that covers it from a third, and pull them all into one buffer where you can read and edit them together.

This is different from split panes. Split panes show full files side by side. Multibuffer shows the exact code you care about, from wherever it lives, in one place. Changes write back to the original files. It’s a way to hold multiple things in focus simultaneously without juggling windows.

For code review, refactoring, or understanding a system you didn’t write, it’s a significant quality-of-life improvement.

Real-time collaboration without setup

Zed’s multiplayer support is built into the editor’s networking layer, not a plugin sitting on top. You open a channel, share a link, and a collaborator joins your session with a live cursor. Both of you can edit simultaneously. There’s no screen-sharing latency, no Teletype plugin to install, no LiveShare auth flow.

This works well for pair programming, code review with a colleague who’s not in the same room, and for the AI use case described below. The implementation being native rather than plugin-based means it’s reliable and doesn’t add startup overhead.

Built-in AI assistant

The AI assistant lives in a panel and supports a wide range of models: Claude Opus 4.7 and Sonnet 4.6, GPT-5, Gemini 3, and local models via Ollama. You can also connect any provider through BYOK, including Amazon Bedrock, Deepseek, Mistral, OpenRouter, and others.

The inline assistant lets you select code, describe a change, and have the edit applied in place. The panel assistant handles longer context conversations. Both work the way you’d expect if you’ve used any AI coding assistant.

What’s different from standalone tools like GitHub Copilot is that the context is always the actual buffer state. Because Zed owns the full editing environment, the model sees what’s actually in the file, not a copy passed through an API with potential sync issues.

Agentic mode and how it differs

The agentic mode is the most recent significant addition and it’s more interesting than a typical “agent” feature because of how it’s wired. When you give an agent a task, it can navigate your codebase autonomously, open files, make edits across multiple locations, and run tools. Those changes appear in Zed’s unified diff view, and because the agent uses the same multiplayer infrastructure as human collaborators, you can follow the agent as it works, watching cursors move and edits land in real time.

That’s a genuinely different experience from most agentic coding tools, where the agent works in the background and you see results when it’s done. In Zed, you can interrupt, guide, and review incrementally. The tool permission system lets you control what the agent can touch, and MCP server support means you can extend what context the agent can access.

It’s still maturing. Complex multi-step tasks occasionally go sideways in ways that require manual cleanup. But the live visibility makes those situations recoverable in a way that background agents don’t.

Pricing

Zed’s pricing is one of its more sensible structures in a market full of confusing tier designs.

The Personal plan is free, permanently. You get 2,000 accepted edit predictions per month through Zed’s hosted Zeta model. For anything beyond that, you can bring your own API keys from any supported provider at no additional cost. If you’re already paying for Anthropic or OpenAI API access, you can use Zed as your full AI coding environment without paying Zed anything extra.

The Pro plan costs $10/month. It comes with a two-week free trial that includes $20 in credits (note that Anthropic’s Opus models are excluded from the trial). After that, you get unlimited edit predictions and $5 in monthly AI token credits. Usage beyond $5 is billed at standard API rates plus a 10% markup. You can set spending caps to avoid surprises. At $10/month, this is competitive with or cheaper than most AI coding subscriptions, but the $5 credit buffer disappears quickly if you’re running agentic workflows that touch many files.

The Business plan is $30/seat/month. It targets teams that need org-wide model policies, data governance controls, role-based access, and unified spend visibility. There’s no minimum seat requirement, and larger contracts (25+ seats) can negotiate monthly or annual terms.

BYOK is available on every tier, which is the right call. Making developers pay a subscription just to use their own API keys is a friction that Zed has avoided.

Where Zed wins and where it doesn’t

Zed wins clearly on performance, on the editing model itself, and on built-in features that other editors add through plugins. Multiplayer, AI, Git staging and diffing, a debugger, LSP support, Vim mode: these all ship with the editor. The total software weight is lower than a fully configured VS Code instance.

The honest weakness is extensions. VS Code has a marketplace with tens of thousands of extensions. JetBrains has a deep catalogue for language-specific workflows. Zed has a growing ecosystem, but if your current workflow depends on specific plugins, you need to check whether equivalents exist before committing to a switch.

A few categories where gaps are real: advanced database tooling, specialized framework integrations, and some language-specific extensions that VS Code has had for years. Language server support through LSP covers the core language features, but the long tail of VS Code plugins is not there.

Windows support is functional but arrived later than macOS and Linux. The experience is solid for most workflows, but macOS remains the most polished platform.

The Jupyter/notebook support is limited compared to VS Code. There’s a REPL with Jupyter kernel support, but if your work is heavily notebook-oriented, VS Code’s notebook integration is more mature.

Who Zed is built for

The clearest fit is a backend or full-stack engineer on macOS who has started noticing VS Code’s performance limits, does most of their work in a small set of languages with strong LSP support, and wants AI tooling without a second subscription on top of whatever they’re already paying for API access.

A close second fit is anyone doing real-time collaborative development. Pair programming, technical interviews, live code review with distributed teams: Zed’s built-in multiplayer handles all of these without setup friction.

It’s also worth considering if you’re evaluating tools for AI-assisted coding and want an environment where the AI is integrated into the editor rather than layered on top of one. The agentic mode’s live visibility is a design choice that suits engineers who want to stay in the loop rather than hand off work entirely.

It’s not the right fit if your workflow depends on a dense VS Code extension setup, if your team is standardized on JetBrains tools, or if you work primarily on Windows and need a fully mature experience today.

Zed vs the alternatives

Zed vs Cursor: Cursor is VS Code with strong AI integration. That means you get the full VS Code extension ecosystem, which is a real advantage if you depend on it. Cursor’s codebase indexing and tab completion are mature and well-regarded. Zed is a faster editor, has tighter AI integration at the architecture level, and costs less if you’re already paying for API keys. If the VS Code ecosystem is non-negotiable, use Cursor. If editor performance matters and your extension needs are modest, Zed is the better daily experience.

Zed vs Windsurf: Windsurf is also VS Code-based, built by Codeium, with its own AI model and “Flow” agentic system. Windsurf has a strong free tier and competitive AI features. Zed wins on performance and architecture. Windsurf wins on extension compatibility and the maturity of its free AI offering. If budget is the primary constraint and extension compatibility matters, Windsurf is worth evaluating. If you’re willing to pay $10/month and want raw editor speed, Zed is the better foundation.

Zed vs GitHub Copilot in VS Code: This is the most common comparison for people on the fence. Copilot in VS Code is a known quantity: you keep your current environment and add AI on top. The cost is roughly comparable depending on your plan. Zed with Pro gives you a faster editor, built-in multiplayer, and AI that’s more deeply integrated rather than plugin-based. The question is whether the VS Code ecosystem is worth the performance overhead. For many developers, the answer is still yes. But the answer is changing for a meaningful number of them.

Compared to Claude Code, which is a terminal-based agentic coding tool, Zed is a full editor environment with a GUI. They can complement each other. Claude Code for terminal-driven agentic tasks, Zed for the editing environment you live in.

Getting started

Download from zed.dev. On macOS, it’s a standard drag-to-Applications install. On Linux, there’s an install script or you can build from source via the GitHub repo. Windows has an official installer.

On first launch, Zed will ask you to sign in with GitHub for the free Personal plan. AI features are available immediately after that. To use BYOK, open the settings, navigate to the AI section, and add your provider API key. The interface for this is straightforward and takes about two minutes.

For multiplayer, open the Channels panel and create a channel or share your current project. Invite links are copyable directly from the editor. Collaborators need a Zed account, which is free.

The Vim mode is opt-in and works well. If you’re a Vim user making the jump from Neovim or a Vim-mode VS Code setup, it’s worth enabling before you decide whether Zed fits your muscle memory.

The learning curve is low if you’re coming from VS Code. The keybindings are different in some places, but the mental model maps closely.

The bottom line

Zed has done something that very few projects pull off: shipped a ground-up rewrite of a mature category and made it genuinely better in ways that matter daily. The performance advantage is real and durable because it comes from architecture, not optimization tricks. The AI features have caught up to the point where switching from a VS Code-based AI tool doesn’t mean accepting a downgrade.

The extension ecosystem is the legitimate reason not to switch, and it’s worth taking seriously before you commit. But if you check your critical extensions and they’re covered, there’s a strong case that Zed is the better editor to work in every day. For engineers who care about the tools they spend eight hours a day inside, that’s the kind of thing worth trying.

Key features

• GPU-accelerated rendering at 120fps written in Rust
• Multibuffer editing across multiple files in one surface
• Real-time multiplayer collaboration with live cursors
• Built-in AI assistant with support for Claude, GPT, Gemini, and local models
• Agentic editing mode with autonomous context discovery and file editing
• Edit predictions via Zeta (open-weight, trained on real dev workflows)
• MCP server support for extending agent context

Pros and cons

Who is Zed for?

• Backend engineers on macOS or Linux who care about editor latency and want AI without a separate subscription tool
• Teams doing live pair programming or code review who want real-time collaboration without overhead
• Developers already paying for Anthropic or OpenAI API access who want BYOK to avoid a second AI bill
• Engineers migrating away from VS Code who don't want to give up modern AI coding features

Alternatives to Zed

If Zed isn't quite the right fit, the closest alternatives are cursor , windsurf , and github-copilot . See our full Zed alternatives page for side-by-side comparisons.