Zed Editor: The Fight for Milliseconds
Zed started with disobedience: a few devs refusing “good enough.” From Atom to Zed, Antonio Scandurra shows how obsession with speed, performance, and craft shapes tools that feel telepathic. Build for flow, guard the core, and honor invisible labor.
It Starts With Disobedience
Like most revolutions, it didn’t start with a press release.
It started with a quiet refusal.
A few developers, unsatisfied with the status quo, staying after hours to build the tools they wished existed.
In the DevTools.fm podcast, Antonio Scandurra—co-founder of Zed and core contributor to Atom—pulls us into that world. A place where text editors aren’t just codebases. They’re living experiments in speed, extensibility, and creative control.
What follows isn’t just Zed’s technical backstory. It’s a meditation on the cycles of innovation. On the hazards of unchecked extensibility. On the obsessive pursuit of craft.
From Awe to Open Source
Antonio’s journey starts with awe.
Watching his father work formulas in Excel. Seeing for the first time how a machine bends to human intent.
From there: early coding experiments. Then deep into open source.
He found himself hacking on Atom because splitting selections into lines was too slow for his liking. That frustration became pull requests. Pull requests became pair programming with Nathan Sobo.
Soon, GitHub brought him into the Atom core team.
Every performance log. Every API exposed. Every plugin gone rogue. They all left a mark—lessons learned in late nights and buggy mornings.
Atom’s Lesson: Power and Peril
Atom’s explosion of extensions was glorious.
And dangerous.
Too many freedoms meant incompatible APIs, broken experiences, and a codebase trapped by backward compatibility.
Lesson one for the Zed team: extensibility is power, but it’s also peril.
Zed’s answer? Versioning became sacred. Plugins got boundaries. Performance came first, every time.
Performance as a North Star
For Zed, performance isn’t a metric. It’s a religion.
Rust at the core. Owning every layer—from shader code to text rendering.
Milliseconds are cut without mercy.
Atom and Electron carried Chromium’s overhead. Purple blocks clogged the DevTools timeline. Zed’s engine is purpose-built.
Startup? Under half a second.
Tree-sitter parses incrementally in microseconds.
Buffers? Not conventional. B-tree-backed, CRDT-enabled “sump trees.” Collaborative editing at speeds that feel telepathic.
Collaboration Without Compromise
Collaboration wasn’t bolted on. It was a core challenge from day one.
Antonio breaks down the CRDT experiments. Every keystroke, even in a global pair-programming session, had to feel instant.
This isn’t just a feature. It’s craft.
Every technical decision answers one question: Will this interrupt the flow of thought?
If yes, it’s gone.
The Hard Part: Building From Bedrock
Zed’s UI framework—GPUI—was rewritten from scratch in Rust.
Ambitious. Daunting.
Without legacy abstractions, the team had total control. And total responsibility.
Shader code, SDFs, reactive paradigms—all tuned to Zed’s needs.
No hand-me-downs. No safety net.
Each day was both freedom and burden. Missing documentation. No roadmap but their own.
It’s why most teams start on someone else’s mountain instead of carving their own from rock.
Plugins With Discipline
Zed’s plugin system is pragmatic.
Performance-constrained. Sandboxed via WebAssembly. APIs exposed only if they can be supported without breaking speed or stability.
The goal: prevent the slow bleed of “just one more plugin” from rotting the core.
Stay open to the community’s creativity—but guard the foundation.
Beyond the Code
Beneath all the technical detail lies a deeper truth about toolmaking.
Each innovation, earned in obscurity, can seed a new ecosystem.
Atom’s legacy lives on—in Electron, VS Code, the Language Server Protocol.
Zed’s legacy? It’ll be measured in snappy keystrokes, in seamless collaboration, in a higher standard for what a text editor can be.
The Parable for Builders
For indie hackers, founders, and creators, Zed’s story reads like a parable.
Build for speed, but never at the cost of clarity.
Learn from the ghosts of features past.
Say yes only to what you can support over time.
Ritualize reflection. Celebrate performance. Defend your flow.
Whether you’re writing code, prose, or building your own company—it’s the same discipline.
The Invisible Labor Beneath Your Editor
Tomorrow, when you open your editor of choice, remember:
The late-night experiments.
The architectural pivots.
The stubborn refusal to accept “good enough.”
Every tool you use began as restless curiosity. The impulse to chase speed. To demand control. To make something better.
The Rallying Cry
Zed’s story is more than technical achievement.
It’s a reminder to honor that impulse. To sharpen your tools. To build with intent.
Because when you fight for milliseconds, you reclaim hours.
And sometimes—whether in software or in life—that’s the real revolution.