Zed (code editor)
Last reviewed
May 8, 2026
Sources
36 citations
Review status
Source-backed
Revision
v1 ยท 5,428 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 8, 2026
Sources
36 citations
Review status
Source-backed
Revision
v1 ยท 5,428 words
Add missing citations, update stale details, or suggest a clearer explanation.
Zed is an open-source, AI-native code editor written in Rust and developed by Zed Industries, the company founded by several of the creators of Atom and Tree-sitter. Zed combines a custom GPU-accelerated UI framework called GPUI, native Tree-sitter parsing, and first-class Language Server Protocol support to deliver an editor designed for very low input latency, real-time multiplayer collaboration, and integrated large language model workflows. The editor was first made available as a closed alpha on macOS in 2022, open-sourced on January 24, 2024, and reached version 1.0 with feature parity across macOS, Linux, and Windows on April 29, 2026.
Zed's defining characteristic is that it was built from scratch in Rust rather than as a fork of an Electron-based editor. The team's stated goal is for the editor to disappear: cursor movement, file switching, and multi-file edits are designed to render at the display's native refresh rate, which on macOS and Linux can reach 120 Hz on supported hardware. The editor is distributed under three different open-source licenses depending on the component: the editor itself is licensed under GPL-3.0, the GPUI framework and various SDKs under Apache-2.0, and the collaboration server under AGPL-3.0.
Zed has emerged as one of the principal alternatives in the AI code assistant editor category, alongside Cursor and Windsurf, while taking a markedly different approach. Instead of forking VS Code, the Zed team built a new editor and grafted AI agent features onto it, including an Assistant Panel, Inline Assistant, an Agent Panel for autonomous coding sessions, and a native edit-prediction engine driven by Zed's own open-weights model, Zeta.
| Field | Detail |
|---|---|
| Type | Code editor / IDE |
| Developer | Zed Industries, Inc. |
| First released | June 2022 (private alpha, macOS) |
| Open-sourced | January 24, 2024 |
| Version 1.0 | April 29, 2026 |
| Written in | Rust |
| UI framework | GPUI (custom, GPU-accelerated) |
| Parser | Tree-sitter |
| License | GPL-3.0 (editor); Apache-2.0 (GPUI, SDKs); AGPL-3.0 (collab server) |
| Platforms | macOS, Linux, Windows |
| Repository | github.com/zed-industries/zed |
| Website | zed.dev |
The story of Zed begins with Atom. Nathan Sobo joined GitHub in late 2011 to build a hackable text editor as part of the GitHub team. Atom shipped in beta in 2014 and went 1.0 in 2015. It became one of the most influential text editors of the decade, in part because the Electron framework that Atom invented to ship a desktop app written in HTML and JavaScript later became the foundation for Visual Studio Code, Slack, Discord, and many other applications.
Max Brunsfeld joined the Atom team in 2013. While working on Atom by day, Brunsfeld spent nights and weekends building Tree-sitter, a general parser generator and incremental parsing library that GitHub eventually adopted to power code analysis across github.com. Tree-sitter went on to be embedded by Neovim, Helix, Emacs, and many other projects. Antonio Scandurra joined the Atom team in 2014 while still in university, after his open-source contributions caught the team's attention. He co-led the development of Teletype for Atom, an early production use of conflict-free replicated data types (CRDTs) for collaborative text editing.
By the late 2010s, Sobo and the Atom team were running into a hard ceiling. Atom was built on web technology, and that meant rendering through a browser engine, garbage-collected JavaScript on the hot path, and DOM-based input handling. No amount of optimization could close the gap between web rendering and a native, GPU-driven pipeline. In a now-widely-cited blog post titled "We Have to Start Over," Sobo described the realization that to build the editor he wanted, the team would have to throw away Atom and rewrite from scratch in a language with manual memory management and direct access to the GPU.
Sobo founded Zed Industries in 2021. The early team was composed largely of ex-Atom engineers, including Brunsfeld and Scandurra. Conrad Irwin, formerly VP of Engineering at the error monitoring company Bugsnag and CTO at the email client Superhuman, joined Zed in 2023 to work on the collaboration system. Sobo, Brunsfeld, and Scandurra are routinely listed as co-founders of Zed Industries, with Irwin joining later as a senior engineer; popular accounts sometimes describe all four as co-founders, though the most commonly cited founding trio in funding announcements and press coverage is Sobo, Brunsfeld, and Scandurra.
Zed Industries raised a $10 million round in 2023. In November 2024, the company announced a $32.4 million Series B led by Sequoia Capital, with participation from Redpoint Ventures, Root Ventures, V1 VC, and Matchstick Ventures. The round was led by Sequoia Capital. Earlier rounds had included Andreessen Horowitz. The Series B financing was widely interpreted as a bet that AI coding workflows would shift away from VS Code forks and toward natively designed editors.
Zed entered private alpha in June 2022, the same month GitHub announced that Atom would be sunset. Atom was officially archived on December 15, 2022. The early Zed builds ran only on macOS and were distributed by invite. The product slowly expanded in 2023, adding Vim mode, an early Assistant Panel, and the channels-based collaboration system that the team uses internally as their virtual office.
On January 24, 2024, Zed Industries published a blog post titled "Zed is now open source" and pushed the editor's source code to GitHub under the GPL-3.0 license. The collaboration server was released under AGPL-3.0, and the GPUI framework along with the language server adapters and other supporting libraries were released under Apache-2.0. The decision to open source the entire codebase, including the server, was unusual among commercial editors at the time. The team explained that their business model would shift to selling AI services and team features that integrated with the open-source editor, rather than charging for the editor itself.
The open-sourcing announcement coincided with a rapid increase in attention to Zed. The repository climbed quickly past 30,000 stars in the days following the announcement and continued to grow throughout 2024 and 2025, reaching roughly 78,000 stars by mid-2026. Phoronix, The Register, Ars Technica, and Hacker News all covered the move; the Hacker News thread on the open-source announcement spent several days near the top of the front page.
Linux support shipped in 2024. Windows support went through a long beta. A public Windows beta was released in late September 2025, with the stable Windows build following on October 15, 2025. By the time of the 1.0 release, the team described macOS, Linux, and Windows as shipping at "full parity," though the macOS build remains the most polished because of the team's deep familiarity with Metal and the unified memory architecture of Apple silicon.
Zed 1.0 shipped on April 29, 2026, almost exactly five years after the company was founded. The 1.0 release added persistent bookmarks, a git: view commit command in the palette, a single "disable all AI features" toggle, and built-in support for DeepSeek-V4-Pro and DeepSeek-V4-Flash. The 1.0 announcement explicitly framed the release as a stability milestone rather than a claim that the editor was finished. Several headline features for AI workflows landed alongside 1.0, including parallel agents (multiple agents working concurrently in the same window), a Zed for Business plan with centralized billing, and an expanded set of external Agent Client Protocol (ACP) integrations including Cursor itself.
Zed is the product of a small set of architectural choices that the team has stuck to with unusual stubbornness. The editor is written in Rust, renders through a custom UI framework called GPUI, parses code with Tree-sitter, and talks to language servers through the standard Language Server Protocol. Each of these decisions was deliberate.
The entire editor is written in Rust, including the UI framework, the editor core, the language server adapters, the collaboration runtime, and the AI features. The Rust codebase is large; estimates from contributors and DeepWiki put it well above 500,000 lines of Rust. Rust gives the team predictable performance (no garbage collection pauses), zero-cost abstractions, and a strong type system that catches concurrency bugs at compile time. The async runtime Zed uses is built on top of smol and a custom executor, allowing language server communication, file I/O, and network calls to happen concurrently without blocking the UI thread.
GPUI is Zed's custom UI framework. Unlike most desktop UI toolkits, GPUI does not wrap a browser engine, a system control set, or a retained-mode scene graph. Instead, it draws every UI element on the GPU through Metal on macOS and Vulkan on Linux and Windows. GPUI's rendering pipeline batches draw calls into a small number of GPU shaders for shapes, text glyphs, and images, then submits them once per frame.
The framework uses an immediate-mode style API for application code with a retained-mode rendering layer underneath, similar in spirit to Apple's SwiftUI. UI components are described as functions of state, and GPUI handles diffing, layout, and dispatch to the GPU. Text rendering uses CoreText on macOS and a custom shaper on Linux and Windows, with subpixel antialiasing performed in fragment shaders.
GPUI is shipped under the Apache-2.0 license, separately from the editor, so other Rust projects can use it. A handful of unrelated applications have shipped on GPUI, although it remains primarily a Zed-internal framework. The team has periodically discussed splitting GPUI into its own repository, but as of 2026 it lives in the main Zed repository.
Tree-sitter, originally developed by Brunsfeld for Atom, is embedded directly in Zed. Tree-sitter is an incremental parsing system: when a user types a character, only the affected subtree is reparsed using a zipper data structure, so syntax highlighting and structural queries stay accurate during fast typing. Zed uses Tree-sitter for syntax highlighting, the outline panel, code folding, indent calculation, structural selections, and most navigation features.
Language support in Zed is delivered through a combination of a Tree-sitter grammar, an LSP adapter that knows how to spawn the relevant language server, and optional configuration. Most language support ships as extensions rather than living inside the core repository.
Zed implements the Language Server Protocol natively. Each language server runs as a separate process, communicating over stdio or a socket. Zed's async runtime handles LSP requests without blocking the UI, which means even a slow language server cannot freeze the editor. Diagnostics, completions, hover, code actions, rename, references, and go-to-definition are all sourced from LSP. Zed also integrates LSP code lens (added in late 2025) and inline hints.
Zed supports running multiple language servers per buffer, so Tailwind CSS support and TypeScript support can both be active in the same React file, for example. The code-completion menu merges suggestions from all active servers along with snippets and AI predictions.
The collaboration server is a separate Rust process that runs at collab.zed.dev for the hosted service. The server brokers WebRTC connections between collaborators, distributes editor operations as CRDT changes, and stores channel notes. The CRDT implementation is a derivative of the work Scandurra and others did on Teletype during the Atom era.
Multiple developers can edit the same buffer simultaneously, each with their own cursor, viewport, and undo history. Voice and screen sharing are layered on top of the same WebRTC infrastructure. The collaboration server can also be self-hosted, although the supporting documentation is sparse and the service is more commonly used through Zed's hosted instance.
| Platform | Status | First shipped | Notes |
|---|---|---|---|
| macOS | Stable | June 2022 (private alpha) | Most polished; uses Metal directly. Apple silicon recommended. |
| Linux | Stable | October 2024 | Renders through Vulkan. Wayland and X11 supported. |
| Windows | Stable | October 15, 2025 | Public beta in September 2025; full parity with 1.0 in April 2026. |
| Web / browser | Not supported | n/a | No browser version exists; editor is native only. |
The macOS build is the reference implementation. The team builds on macOS, runs CI on macOS, and tests other platforms against the macOS feature set. As a result, very small UI behaviors can lag on Linux and Windows for a release or two, although the gap is narrower than it was during the Linux beta.
Zed ships with a familiar set of features for a modern code editor: multi-cursor editing, project-wide search and replace, integrated terminal, file finder, command palette, project search, and split panes. Many of these are accessible through both the GUI and Vim-style keyboard commands.
Zed has a built-in Vim mode that aims to replicate the behavior of motions and commands from Vim itself, including text objects, operators, and registers. The implementation includes surround text objects (ys, cs, ds), comment toggle (gc), visual block selection backed by Zed's multi-cursor system, and navigation commands like gd for go-to-definition and gh for hover. The : command line accepts a subset of Ex commands, including :w, :q, :e, and :diffsplit. The Vim mode is enabled by setting "vim_mode": true in the configuration. There is no Helix mode, but the Helix-style amp jump navigation was added as a built-in feature in late 2025 for non-Vim users.
The Multibuffer is one of Zed's signature features. A Multibuffer is a single editable surface that aggregates excerpts from multiple files. Project search results, find-all-references results, and Git diffs all open as multibuffers, which means the user can search and edit across many files at once without switching tabs. Changes made inside a Multibuffer are reflected in the underlying files. Multi-cursor editing across a Multibuffer enables wide-ranging refactors that would normally require an external script.
The multi-cursor system is built on the same primitives as the collaboration system. cmd-d (or ctrl-d on Linux/Windows) selects the next match of the word under the cursor, and cmd-shift-l selects all matches. Multiple cursors interact correctly with Vim's visual block mode, which under the hood is just multi-cursor with shared column constraints.
Zed has native Git integration. The Project Diff view is a Multibuffer that aggregates all unstaged and staged hunks across the project. Each hunk can be staged or unstaged with a keybinding, and inline blame is available in the gutter. As of late 2025, Zed includes a git graph view for browsing branches and a git: view commit command palette action for opening a single commit's changes as a Multibuffer.
The integrated terminal is a full xterm-compatible terminal emulator written in Rust. Multiple terminals can be opened in the bottom panel or as full editor tabs. Terminal output is searchable and link-detected, so file paths and URLs become clickable.
Every collaboration channel comes with a Markdown notes file that all members can edit simultaneously. Channel notes are real-time collaborative documents, so they double as a shared whiteboard during pair-programming sessions.
Zed treats AI features as a first-class part of the editor rather than as bolted-on plugins. Configuration lives in the same settings.json as other editor settings, AI panels live in the same dock system as the file explorer, and AI-generated edits flow through the same edit log as human edits.
The Assistant Panel was Zed's first AI feature, introduced during the closed alpha and developed throughout 2023 and 2024. It started as a chat panel that could attach the open file, the current selection, or arbitrary slash commands as context. Slash commands let extensions inject context, for example /fetch <url> for retrieving a web page or /file <path> for attaching a file. The Assistant Panel served as the original entry point for users to talk to a large language model inside Zed.
The Inline Assistant is a prompt-driven transformation feature. The user selects a region of code or moves to an empty line, presses cmd-enter, and types an instruction. Zed sends the selection plus the prompt to a language model and replaces the selection with the response, presented as an inline diff that the user can accept or reject. The Inline Assistant is the most direct AI editing surface in Zed and is intended to be muscle-memory fast for small refactors.
The Agent Panel is Zed's autonomous coding agent surface. It superseded the original Assistant Panel as the primary AI experience starting in 2025. The agent has access to tool calls including reading files, writing files, searching the project, running terminal commands, and calling MCP servers. The Agent Panel runs in either a manual mode (the user approves each tool call) or an automatic mode (the agent runs to completion and presents a final diff). All agent edits flow through Zed's CRDT, so a human can follow along in real time, jump into a buffer to fix something, and continue letting the agent work.
In early 2026, Zed added a parallel agents feature, allowing multiple agents to run concurrently in the same window. Each agent is sandboxed in its own checkpoint, so the user can compare the results of two agents tackling the same task. The 1.0 release also added support for external agents through the Agent Client Protocol (ACP), an open protocol that Zed has been developing in collaboration with Google and JetBrains. Cursor itself can be invoked as an external ACP agent inside Zed, and Zed's own agent can also be invoked from other ACP-compatible editors.
Edit Prediction is Zed's name for next-edit prediction. After every keystroke, the editor sends a small request to the configured prediction provider and receives a single or multi-line suggestion that the user can accept with tab. Edit Prediction is broader than autocomplete: it predicts the user's next edit anywhere in the file, including deletions and refactors that span several lines, not just the next token at the cursor.
The default Edit Prediction provider is Zeta, an open-source, open-data edit-prediction model trained by Zed Industries and released as the team's first AI release of 2025. Zeta and its successor Zeta2 are open-weight models that can be downloaded and self-hosted. Other providers are also supported: GitHub Copilot's prediction model, Codestral, Mercury Coder, and any custom provider that speaks the OpenAI-compatible completion API. Free Zed accounts get 2,000 Zeta predictions per month, and the Pro plan removes the limit.
Zed integrated the Model Context Protocol (MCP) on November 25, 2024, in collaboration with Anthropic. MCP support originally landed as Context Server Extensions: third-party developers could publish a Zed extension that ran an MCP server providing tools, prompts, and slash commands inside the Assistant Panel. With the move to the Agent Panel, MCP servers became first-class tool providers for the agent. Zed currently supports MCP's Tools and Prompts features, with ongoing work to support newer revisions of the MCP spec.
MCP server extensions are distributed through the Zed extension marketplace at zed.dev/extensions, and the registry includes servers for Supabase, GitLab, Context7, and dozens of other services.
Zed is provider-agnostic for AI features. Users can route requests to a hosted Zed AI service, to a third-party provider with a personal API key, or to a self-hosted local model. The supported providers as of 2026 are listed below.
| Provider | Authentication | Notes |
|---|---|---|
| Anthropic | API key or Zed AI subscription | Supports Claude Opus, Sonnet, and Haiku. Claude Opus 4.7 added as a BYOK model in April 2026. |
| OpenAI | API key or Zed AI subscription | Supports GPT-5 and earlier GPT models, plus the OpenAI compatible chat completion API for any custom endpoint. |
| API key | Gemini 2.x models. | |
| GitHub Copilot | OAuth | Uses the user's existing Copilot subscription for chat and edit predictions. |
| Amazon Bedrock | AWS credentials | Routes to Anthropic, Mistral, and other Bedrock-hosted models. |
| DeepSeek | API key or Zed AI subscription | DeepSeek-V4-Pro and DeepSeek-V4-Flash added natively in April 2026. |
| Mistral | API key | Cloud Mistral models, plus Codestral for edit predictions. |
| LM Studio | Local | Runs any local model through LM Studio's OpenAI-compatible server. |
| Ollama | Local | Native Ollama provider; popular for local models like Llama, Qwen, and DeepSeek distillations. |
| OpenRouter | API key | Aggregator that exposes hundreds of models behind one key. |
| Vercel | API key | Vercel AI Gateway. |
| Custom OpenAI-compatible | URL + API key | Any endpoint speaking the OpenAI chat completion or completion API. |
Zed's design separates the model selection from the feature, so each AI feature (Edit Prediction, Inline Assistant, Agent Panel) can be wired to a different provider. A typical configuration might use a local Ollama model for edit predictions and a hosted model from Anthropic for the Agent Panel.
Zed AI is the company's hosted AI service. It bundles access to Anthropic's Claude, OpenAI models including GPT-5, Google's Gemini, and DeepSeek models behind a single subscription, with no need for users to manage individual API keys. The service was first announced in August 2024 in collaboration with Anthropic.
The pricing structure changed substantially in October and December 2025, when Zed migrated from a flat-rate plan to token-based pricing. The current plan structure is:
| Plan | Monthly cost | Included credits | Edit predictions | Notes |
|---|---|---|---|---|
| Personal | Free | None | 2,000 Zeta predictions | Editor-only or BYOK; no hosted AI included. |
| Pro | $20 / month | $5 of token credits | Unlimited Zeta predictions | Two-week free trial includes $20 of credits. |
| Student | Free for one year | $10 / month of token credits | Unlimited Zeta predictions | Requires verified university enrollment. |
| Business | Custom | Pooled token credits | Unlimited Zeta predictions | Centralized billing; available with Zed 1.0. |
Under the new structure, every model has a per-token price, with Zed adding a 10% markup over the underlying provider's wholesale price to cover infrastructure and rate-limit headroom. Free-plan users transitioned to the new pricing on October 15, 2025, and Pro users had until December 17, 2025 to migrate.
The editor itself, the Zeta model, GPUI, and the Agent Client Protocol are all free and open source regardless of which plan the user is on. Users on the Personal plan can bring their own API keys for any supported provider and pay nothing to Zed.
A channel in Zed is a persistent room that maps to a project or workstream. Channels have members, an associated Markdown notes file, a voice room, and zero or more shared projects. Members of a channel can join with one click and start editing the same files together. The team uses channels internally as their virtual office, holding ad-hoc design discussions inside a shared editor instead of in a video call.
Multiple users can edit the same buffer simultaneously, each with their own cursor and viewport. The CRDT implementation handles conflicts deterministically, so editors stay in sync even on flaky connections. Each collaborator has an independent undo history, so undoing one person's edit does not undo someone else's.
Voice chat is built directly into the editor, accessed through the microphone icon in the collaboration panel. The voice connection is low-latency WebRTC inside the same room as the shared editor, so it is closer to a phone call than to a typical video conferencing app. Screen sharing is also available through the title-bar share button. Screen sharing is mostly used to show external apps; for code, the shared editor is sufficient.
A collaborator can choose to follow another collaborator. The follower's view tracks the leader's cursor, file switches, and scroll position. This is the same multiplayer infrastructure that the Agent Panel uses to let a human follow an AI agent: the agent appears as another participant whose cursor and edits are visible in real time.
Zed has a community extension system. Extensions can deliver languages, themes, slash commands, debugger adapters, and MCP servers. Extensions run as WebAssembly modules sandboxed inside the editor, with a versioned API defined through WebAssembly Interface Type (WIT) files. The extension API crate is zed_extension_api, distributed on crates.io. Extensions are typically written in Rust, but any language that can target WASM can in theory be used.
The extension marketplace at zed.dev/extensions hosted hundreds of extensions as of 2026, covering most popular programming languages, several dozen themes, and a growing list of MCP server bridges. To publish an extension, a developer opens a pull request to the zed-industries/extensions repository on GitHub. There is no separate review queue or paid developer account.
Zed has received broadly positive press since open-sourcing. Phoronix, The Register, Ars Technica, InfoQ, DevClass, and Gigazine all covered the open-source announcement in January 2024. The Hacker News thread on the announcement spent several days near the top of the front page. Coverage emphasized the editor's startup speed, low input latency, and the fact that the entire editor (including the collaboration server) was open source rather than a stripped-down community edition.
The project's GitHub star count climbed from roughly 12,000 at the time of open-sourcing to roughly 78,000 by mid-2026, putting it among the most-starred Rust projects on GitHub. Active contributors number in the high hundreds, with the bulk of code coming from Zed Industries employees.
Adoption among AI-savvy developers has been notable. Zed appears regularly in posts comparing AI editors against Cursor and Windsurf. The reviews tend to settle into a similar pattern: Cursor is described as the most feature-complete agentic editor and the de-facto winner for users on intel-class hardware; Windsurf is described as more autonomous via its Cascade agent; and Zed is described as the choice for users who care about input latency, native UI, and not running a 1 GB Electron process. The 2 ms input latency that Zed reports on Apple silicon, compared to roughly 12 ms for Cursor on the same hardware, is the number that comes up most often.
The team uses Zed as their own daily driver, including the collaboration features, and several blog posts ("Zed Is Our Office," "Hired Through GitHub") describe the team's hiring process and remote-work setup as built around the editor itself.
| Feature | Zed | Cursor | Windsurf | VS Code |
|---|---|---|---|---|
| Implementation | Native Rust | Electron / VS Code fork | Electron / VS Code fork | Electron |
| Open source | Yes (GPL/Apache/AGPL) | No (proprietary) | No (proprietary) | Yes (MIT) |
| Native binary | Yes | Yes (via Electron) | Yes (via Electron) | Yes (via Electron) |
| GPU rendering | Yes (Metal/Vulkan) | No | No | Limited |
| Reported input latency | ~2 ms | ~12 ms | ~12 ms | ~10 ms |
| Built-in collaboration | Yes (multiplayer + voice) | Limited | Limited | Live Share extension |
| AI Edit Prediction | Yes (Zeta) | Yes (Cursor Tab) | Yes (Tab) | Via Copilot |
| Agent mode | Yes (Agent Panel) | Yes (Agent / Composer) | Yes (Cascade) | Via Copilot |
| MCP support | Yes | Yes | Yes | Via extension |
| Extension ecosystem | Hundreds | Inherited from VS Code | Inherited from VS Code | 50,000+ |
| Vim mode | Built-in | Extension | Extension | Extension |
| Free tier | Editor free; 2,000 predictions/mo | Limited free | Limited free | Free editor + Copilot Free |
| Pricing model | Token-based AI | Fixed tiers | Quota-based | Pay for Copilot |
The table is necessarily a snapshot. Cursor, Windsurf, and VS Code with GitHub Copilot are all moving targets, and Zed's own feature set has shifted substantially between releases.
Zed is one of the few editors that is open source from end to end, including the collaboration server. The repository is split into many crates under three licenses:
| Component | License | Purpose |
|---|---|---|
| Editor (main binary, most crates) | GPL-3.0 | Editor functionality, AI integrations, language adapters. |
| GPUI | Apache-2.0 | Reusable UI framework for other Rust projects. |
| Language server SDKs | Apache-2.0 | Reusable LSP utilities. |
| Collaboration server | AGPL-3.0 | Backend for channels, voice, multiplayer, and remote development. |
Extension API (zed_extension_api) | Apache-2.0 | Crate for building Zed extensions. |
The choice of GPL-3.0 for the editor is deliberate. The team wanted to ensure that any fork or derivative would itself be open source, which the more permissive Apache-2.0 license would not require. The choice of AGPL-3.0 for the server is similarly defensive: a SaaS provider that runs a fork of Zed's collaboration server and exposes it over the network must release their modifications.
The project's main maintainers are Zed Industries employees, but external contributors handle a meaningful portion of bug fixes and new language support. The team has documented several cases of contributors being hired on the basis of their pull requests, in posts titled "Hired Through GitHub." The governance model is benevolent-dictator: there is no foundation, no formal RFC process, and no vote on direction. Major design decisions are discussed in GitHub discussions and on the team's internal channels.