Zed shipped 1.0 today. After five years of work, more than a million lines of Rust, and a public preview that hundreds of thousands of developers have been running daily, Nathan Sobo and the Zed Industries team posted the milestone on April 29, 2026. I have been a JetBrains lifer for the better part of fifteen years. I tried VS Code. I tried Cursor. I ran code-server on a remote box for a while. None of them stuck. Zed has stuck, and the version-number news is a good excuse to say why.

Clarification, before the rest of this gets confusing. JetBrains IDEs are not built on Electron. The IntelliJ Platform is native-on-JVM, a stack from a much earlier generation of IDE engineering — closer in lineage to Eclipse than to VS Code, with its own different (and heavier) set of tradeoffs that I get into in the JetBrains/Cursor/code-server section below. When the next paragraph says "the product underneath is Electron," it is talking about the post-2014 wave of new code editors that built on Atom and then VS Code and then Cursor. JetBrains is the standing exception to that wave, not part of it.

The short version: for over a decade, every "new" code editor announcement has been the same product wearing different hats. The hat is whatever the announcement is selling — AI, collaboration, themes, a different vendor — and the product underneath is Electron. Same Chromium per window. Same JavaScript on the editor critical path. Same multi-gigabyte memory footprint by lunchtime. Sublime Text held the line on native code editors through the 2010s, but it was a closed-source one-developer product without a real collaboration or AI story. Zed is the first credible open-source, AI-native, GPU-accelerated production editor in the last decade that restarted from below the browser, and 1.0 is the moment the bet finally pays off in public.

What Zed actually is

Zed is a native, GPU-accelerated, Rust-built code editor with its own custom UI framework called GPUI. There is no Electron. No Chromium. No Node runtime sitting between the keystroke and the screen. Rendering goes directly to Metal on macOS, DirectX on Windows, and Vulkan on Linux through a small set of optimised primitives — rectangles, shadows, text, icons, images — drawn the way a video game draws its UI.

The editor is open source. It was open-sourced on January 24, 2024 under GPLv3, with the server-side collaboration components under AGPL and GPUI itself released under the Apache 2.0 license. That last detail matters: it means the rendering framework that makes Zed fast is available for any other project that wants to build a high-performance native UI in Rust, without inheriting the editor's copyleft.

It runs on macOS (since the original preview), Linux as of July 2024, and Windows since October 15, 2025. The framework is designed to render at up to 120 frames per second, with the ceiling reached on Apple Silicon and modern Linux GPUs. On a 2024-vintage MacBook Pro that sounds like marketing copy until you actually see a scroll bar that doesn't tear and a cursor that lands the same frame you press the key.

The team, and the Atom lesson

The three founders are Nathan Sobo, Antonio Scandurra, and Max Brunsfeld. The names matter because the trajectory matters.

Sobo joined GitHub in late 2011 as one of the first two engineers on what became Atom, a hackable text editor written in JavaScript and shipped on Electron. Atom was the first big editor to put Electron on the map; for several years it was the canonical example of "build a desktop app with web technology." It hit a million-plus active users and shaped a generation of developer tooling. Brunsfeld joined the Atom team in 2013. While there, he created Tree-sitter, an incremental parsing library that is now the syntax engine inside GitHub's own code-search infrastructure, Neovim, Helix, and most modern editors that take parsing seriously. Scandurra joined in 2014 and co-architected Teletype, Atom's collaborative-editing feature — an early production use of CRDTs (conflict-free replicated data types) for real-time text editing.

Atom was killed by the company that built it. GitHub announced the sunset on June 8, 2022 and discontinued the editor on December 15, 2022, pointing users at VS Code and Codespaces. The reason given was prioritisation; the reason most developers who watched it happen suspected was simpler. VS Code had won the Electron-editor race, and Atom was the loser in a category that GitHub was no longer willing to fund two horses in.

The lesson the founders drew, as the team has stated explicitly in the 1.0 announcement, was that Electron's architecture was the ceiling — not the editor's product decisions, but the platform underneath them. My read of that lesson: a web-stack editor, no matter how well written, will pay a per-keystroke and per-frame tax that a native one will not. Zed Industries was founded in 2021, and the project was announced publicly in 2023. Brunsfeld and Scandurra came along, and the architecture was specifically not the architecture of Atom.

Why the architecture matters

The hard claim Zed is making is that a native, GPU-rendered editor is not "VS Code but a bit faster." It is a different category of responsiveness, and the gap is not subtle.

Antonio Scandurra's engineering post from March 7, 2023, "Leveraging Rust and the GPU to render user interfaces at 120 FPS," walks through the GPUI design. The framework treats the screen as a video-game scene rather than a DOM. Each frame, the CPU describes the scene as a flat list of typed primitives; the GPU draws the entire frame in parallel through optimised shaders. There is no layout-recalculation thread, no garbage collector eating frame budget at random intervals, no Chromium compositor between the editor's intent and the pixel.

The numbers that show up in independent reviews are consistent in their order of magnitude. One commonly cited 2026 benchmark places Zed at roughly 0.4 to 0.6 seconds cold start against VS Code's 1.3, a 2-millisecond keystroke latency against approximately 25, and resident memory in the low hundreds of megabytes against multi-gigabyte VS Code footprints on large monorepos. Different reviewers measure differently, and your mileage will vary by hardware and project size, but the consistent finding is that the gap is one order of magnitude on memory and roughly that on input latency. That is not a tweak. It is a different kind of editor.

You can feel this without a benchmark. Open a 100,000-line monorepo cold. Watch the file tree appear. Type in the global search box. The thing the editor industry has accepted as "the cost of doing business" — the small but persistent friction of an editor that is always on the edge of catching up to your typing — is not present.

What 1.0 actually ships with

Per the 1.0 announcement, the launch is not so much a feature unveiling as a declaration that the editor is ready for the developers who passed on it during the preview. Most of what makes Zed Zed has been shipping incrementally over the last eighteen months.

The agent panel runs multiple AI agents in parallel inside the editor. The "parallel agents" feature shipped on April 22, 2026, one week before 1.0; you can have one agent refactoring a function in one file while another writes tests in another, both visible in their own threads, both editing through Zed's multibuffer review system rather than blind diff-applying. The agents themselves are pluggable. Zed supports the Agent Client Protocol (ACP), an open standard the team published on August 27, 2025 that decouples the editor from the model. Claude Agent, OpenAI's Codex, the open-source OpenCode runner, and Cursor's agent all speak ACP today. JetBrains joined the ACP initiative on October 6, 2025, which is a small but notable detail — the legacy IDE vendor decided not to fork its own protocol.

Edit prediction shipped on February 13, 2025. It is not autocomplete. It is a model trained to predict the next edit at keystroke granularity, displayed inline as a subtle ghost-text overlay you accept with Tab. After a few hours it stops feeling like a feature and starts feeling like the editor is keeping up.

A native debugger shipped on June 18, 2025, integrated into the editor's panel system rather than living in a side window. Native git integration — branch picker, commit viewer, diff staging, blame in the gutter — landed on March 12, 2025. Tree-sitter-powered syntax everywhere, of course. CRDT-based real-time collaboration is inherited directly from the founders' Teletype work at Atom and predates the AI features by years. Vim and Helix keymaps are first-class. There is a settings UI now, for those of us who never quite memorised every JSON key.

The 1.0 release also marks the launch of Zed for Business: centralised billing, role-based access controls, team management. This is the part that pays for the editor everyone else uses for free. It is also the moment the project becomes a business in the way it always intended to be — selling services around an open-source product, not licensing the product itself.

JetBrains, Cursor, code-server: the alternatives I actually tried

I want to be specific about the comparison, because "VS Code is bad" is not what this article is saying.

JetBrains remains, in my honest read, the gold standard for full-IDE features in several languages. IntelliJ's refactoring engine understands cross-module Java better than most things on the market; the database tooling is hard to beat; Kotlin support is, unsurprisingly, first-class. The cost is a JVM startup time you can plan a coffee break around and a memory footprint that competes with the operating system. After fifteen years of paying that cost without complaint — and after watching JetBrains hesitate on its own AI story until very recently — I stopped being willing to pay it for everything.

Cursor is VS Code with an excellent AI integration bolted on top. The AI is genuinely good. The editor underneath is the same Electron baseline, with the same multi-gigabyte memory profile and the same Chromium frame budget. If your bottleneck is "I want better AI in VS Code," Cursor is a real answer. If your bottleneck is "I want an editor that does not feel like a browser tab," Cursor cannot solve that, because it is a browser tab.

code-server runs VS Code in an actual browser, hosted on a remote box you control. It is genuinely useful for some workflows — running an IDE on a beefy server while editing from a thin laptop, or sharing a development environment with a team. It is also another layer of latency on top of an already-Electron editor, and the experience reflects that.

The point of listing these is not to dunk on any of them. It is that for a decade, every credible alternative to "open VS Code on your laptop" has been some flavour of "open VS Code somewhere else." Zed is the first option in a long time that does not start with that as the foundation.

What's next: DeltaDB and the bigger bet

Sequoia Capital led a $32 million Series B in Zed Industries on August 20, 2025, bringing total funding to over $42 million on top of the original $10 million Series A from Redpoint Ventures and others.

The headline use of those funds is DeltaDB: an operation-based version control system using CRDTs to track edits at character-level granularity, designed to interoperate with git rather than replace it. The pitch is that real-time collaboration between humans and AI agents — multiple agents, multiple humans, the same codebase — needs a substrate that records intent at finer resolution than a git commit. The team has said DeltaDB will itself be open-sourced, with an optional paid synchronisation service for teams that don't want to run their own.

The public roadmap lists the rest of the bet. Instant project sharing — hand someone a link, they're editing your code in their browser, no setup. Code history as agent context, so the agent can see how a function got the way it did. Async branch collaboration. A plan mode for the agent that writes a strategy before touching code. Hands-free coding via voice. Notebook-style interactive cells. Zed on the Web, opening any project from any device.

Read it as roadmap, not as ship-list. Some of it will land in 2026; some of it will slip; some of it may quietly disappear. What I take from the published roadmap is that the team is not declaring the editor done. 1.0 is the moment the foundation is solid. The interesting work is what gets built on top of it.

The honest caveats

Switching editor mid-project is rarely a good idea, and Zed is not a perfect drop-in replacement for everything VS Code or JetBrains does today. A short list of what to expect:

• Extension ecosystem is small. Zed's extension model is WASM-based, sandboxed, technically nicer than VS Code's Node-based one. The breadth is not there yet. If you depend on a specific niche VS Code extension, search the Zed extensions directory before you commit to switching, and assume the answer is sometimes "not yet."
• Language intelligence is uneven. Rust, TypeScript, Python, Go are excellent. JetBrains-grade Java refactoring across multimodule projects, or the depth of IntelliJ's database tooling, is not yet there. If those are your daily bread, Zed is not a one-for-one swap today.
• Terms-of-service language deserves a careful read. The Hacker News thread on the 1.0 launch surfaced concerns about the breadth of rights granted around source-code processing for telemetry and AI features. Several of those defaults are configurable; one or two of them require an opt-out. Read the ToS, set the AI defaults consciously, and turn off telemetry if that's your preference. The team is generally responsive on these issues, but the launch-day version is the version you sign up for.
• Hardware sensitivity. GPUI is brilliant on Apple Silicon and on modern Linux GPUs. On older hardware or some Windows configurations, the picture is more uneven; the 120 FPS claim is upper-bound, not floor.
• Some workflows still feel rough. The search-results-in-tabs UX has friction for anyone used to a Telescope-style modal. A few remote-development scenarios are still shy of the comfortable VS Code Remote experience. These are addressable, but they are real today.

None of these are dealbreakers, in the sense that I have switched my daily work to Zed and have not switched back. They are the kind of caveat you would want to know before clearing an afternoon to migrate a serious project.

What this all means

The thing that has been true about code editors for the last ten years is that the architecture stopped mattering, because everyone shipped on the same architecture. The conversation moved up the stack. Themes, AI, collaboration features, plugin marketplaces — those are the layers everyone has been competing on, because the layer underneath was a settled question. You build on Electron, and you negotiate with its constraints.

Zed is a real bet that the architecture is back on the table. The team is not making the bet from outside the industry; they are the people who built Atom, who put Electron on the editor map, and who have spent the last five years deciding it was the wrong foundation for the editor they wanted next. That is a different kind of credibility than "we have a new idea." It is the credibility of people who have already done the thing they are now arguing against.

---

I am not going to tell you to switch tomorrow. Most of the audience for this piece is in the middle of something, and editor switches mid-something are how projects pick up two weeks of unrelated friction.

I am going to tell you that this is the first time in over a decade that the architectural ground under the code editor has shifted, and 1.0 is the day it shifted publicly. A native, open-source, GPU-accelerated, AI-native editor with a real team, real funding, real users, and real momentum is now the alternative to "VS Code but with extras." That alternative did not exist yesterday. It exists today.

Open the download page. Try it on the project you don't mind a little friction on. Spend a week. The decision you make at the end of the week is yours. The thing I want on the record is that the choice is real now, and it has been a long time since that was true.