Zed, a Rust editor and its mixed licences

Zed, a Rust editor and its mixed licences

Zed is a code editor written in Rust by Zed Industries, a company founded by the authors of Atom and Tree-sitter. The stable version 1.16.1 dates from 19 August 2026, the zed-industries/zed repository holds roughly 89 thousand stars, and the licence is not a single one: the core sits on GPL-3.0-or-later while selected directories sit on Apache 2.0.

What Zed is and what it is not

Zed is a native windowed application that draws its own interface through the graphics card, with no browser inside. There is no Electron here, no DOM and no web layer. The interface is drawn by a framework called GPUI, written in the same repository and maintained as a separate library.

Beyond editing text, Zed handles language servers over the LSP protocol, debug adapters over the DAP protocol, Git integration, a terminal, tasks launched from a configuration file, a real-time multiplayer mode and an agent panel. It parses code with Tree-sitter, which has a simple historical cause: Tree-sitter came out of the same company and its author works on the editor.

Three things Zed does not do are worth settling up front. It is not an integrated development environment in the JetBrains sense, so refactorings and project analysis are only as good as the language server you attach. It does not run in a browser, and the gpui_web directory in the repository is work on compiling to WebAssembly rather than a finished feature. Nor does it have an equivalent of the tens of thousands of extensions on the VS Code marketplace, and that is the most serious practical limitation, which I return to separately.

The repository is alive. The last change on the main branch dates from 21 August 2026, the project is not archived, and it carries 10173 forks and 3201 open issues. Stable releases and the preview channel ship roughly weekly, with preview running about seven days ahead of stable.

The licence: GPL-3.0 with Apache 2.0 islands

This is the point where Zed departs from the typical MIT project, and where a dependency audit most easily goes wrong. The GitHub programming interface returns NOASSERTION and the name Other for this repository, meaning it states plainly that it cannot express the factual position as one value.

The factual position, checked against the source tree of release 1.16.1, looks like this. Two files sit in the root directory: LICENSE-GPL with the full text of the GNU General Public License version three, and LICENSE-APACHE headed "Copyright 2022 - 2025 Zed Industries, Inc.". Deeper in the tree there are 215 files named LICENSE-GPL and 47 named LICENSE-APACHE, one in each module directory. The Cargo manifests confirm that split independently: 206 of them declare license = "GPL-3.0-or-later" and 34 declare license = "Apache-2.0". The README describes it in one sentence: Zed source code is licensed primarily under GPL-3.0-or-later, with Apache-2.0 components where marked.

The split is not accidental and can be summarised as a rule. Apache 2.0 covers the parts that make sense as a library outside the editor: gpui together with its whole family of platform modules, extension_api, meaning the interface for extension authors, and a utility set such as collections, sum_tree, util, path, http_client and scheduler. GPL covers the editor itself: editor, project, language, agent_ui, terminal_view and also collab, the server behind the multiplayer mode.

The consequences are concrete. If you build your own application on GPUI or write a Zed extension, Apache 2.0 applies and you may keep your code closed. If you fork the editor and distribute a modified version, GPL-3.0-or-later applies with everything that follows, including the duty to make sources available to recipients. That is a real difference against Cursor or Windsurf, which are closed forks of VS Code.

A belief circulates that part of Zed sits on AGPL. In the tree of release 1.16.1 there is not a single AGPL licence file and not a single manifest with such a field. The only occurrence of that abbreviation is the file script/licenses/zed-licenses.toml, where a comment states plainly that AGPL is not to be added to the list of accepted dependency licences. The accepted list covers Apache-2.0, MIT, MPL-2.0, BSD, ISC, Zlib and several other permissive licences, and compliance is enforced by cargo-about in the continuous integration pipeline.

One more discrepancy helps during an audit. The zed_extension_api package published on crates.io carries the number 0.7.0 from 12 September 2025, while the file crates/extension_api/Cargo.toml in release 1.16.1 declares version 0.8.0. The number from the source branch is therefore not the number you install with cargo add. A separate barrier applies to contributors: before a change is merged you have to sign the copyright assignment agreement published at zed.dev/cla.

# licences declared in the Cargo manifests, counted
grep -rh '^license' --include=Cargo.toml . | sort | uniq -c | sort -rn

# licence files in the tree, grouped by name
find . -name 'LICENSE-*' -type f | xargs -n1 basename | sort | uniq -c

# what the GitHub programming interface thinks of the repository
curl -s https://api.github.com/repos/zed-industries/zed | grep -A4 '"license"'

Where the speed comes from and where it ends

Rust on its own does not make an editor fast. Architectural decisions do, and Rust merely lets you make them without paying for them in garbage collector pauses.

The first is a custom interface engine. GPUI draws the window through the graphics card, with separate backends for macOS, Windows and Linux plus a backend built on wgpu. There is no browser box model here and no cascading style recalculation. The second is the data structure holding text. The buffer sits in a sum tree, implemented in the sum_tree module, so inserting a character in the middle of a hundred megabyte file does not rewrite the buffer. The third is Tree-sitter, which parses incrementally and does not rebuild the whole tree after every keystroke.

The boundaries of that speed are worth knowing before you discover them at work. Highlighting and syntax navigation are fast because Zed does them. Code completion, type checking and quick fixes are done by the language server, which is a separate process and usually not written in Rust. A TypeScript project will respond in Zed exactly as fast as tsserver responds, and no interface engine changes that. Zed speeds up what happens between the keyboard and the screen, not what happens inside the language tooling.

The second boundary is hardware. On Linux the official releases expect a Vulkan-compatible graphics card and a system glibc of at least 2.31 on x86_64 and at least 2.35 on aarch64. On a virtual machine without graphics acceleration or on an older distribution you have to build from source, which requires the Rust toolchain pinned in the repository to version 1.97.1 plus the wasi-sdk for compiling Tree-sitter parsers.

Operating systems, installation and configuration

The order in which the systems arrived is still visible in the documentation. Today the download page lists one stable release, 1.16.1, for all three platforms: macOS 10.15 or newer, Windows on Intel and AMD processors, and Linux through the install script. Windows has a winget package under the identifier ZedIndustries.Zed. There is no browser version, and it is tracked as an open discussion rather than an announcement.

The unevenness has stayed in remote work. Zed can open a project on a remote server over SSH, starting a headless server process there while the interface runs locally. The remote server may be macOS from Catalina onwards or Linux on x86_64 or arm64. Windows is not yet supported in that role, though it may be the local machine connecting to such a server. The older mode, in which traffic went through Zed's servers, was removed in version 0.157, and today's SSH mode needs at least version 0.159.

# Linux, stable channel
curl -f https://zed.dev/install.sh | sh

# Linux, preview channel, releases about a week ahead of stable
curl -f https://zed.dev/install.sh | ZED_CHANNEL=preview sh

# Windows through the package manager
winget install -e --id ZedIndustries.Zed

# opening a directory on a remote server
zed ssh://deploy@192.168.1.10/srv/app

# starting with full logs while diagnosing extensions
zed --foreground

Configuration lives in a single settings.json file, with a separate user version and a project version inside a .zed directory. The schema holds over two hundred top-level fields, so below are only those that get set most often.

{
  "theme": { "mode": "system", "light": "One Light", "dark": "One Dark" },
  "buffer_font_family": ".ZedMono",
  "buffer_font_size": 14,
  "vim_mode": false,
  "tab_size": 2,
  "format_on_save": "on",
  "formatter": [{ "code_action": "source.fixAll.eslint" }, "prettier"],
  "telemetry": { "diagnostics": false, "metrics": false },
  "disable_ai": false,
  "edit_predictions": {
    "provider": "zed",
    "disabled_globs": ["**/.env*", "**/*.pem"]
  },
  "agent": { "enabled": true, "dock": "right" },
  "ssh_connections": [
    { "host": "192.168.1.10", "projects": [{ "paths": ["~/code/app"] }] }
  ]
}

The format_on_save field accepts the values on, off, modifications and modifications_if_available, where the last two format only lines carrying unstaged Git changes. The formatter field accepts a list of steps applied in order, and a single step may be a language server code action, a Prettier invocation or an external command. The disable_ai setting turns off every language model feature at once and is separate from agent.enabled.

Extensions and the size of the ecosystem

Zed's extension registry is a public repository, zed-industries/extensions, holding an extensions.toml file. At the time of writing it contains 1441 entries, of which 429 carry the word "theme" in the identifier and 24 carry the word "icon". Subtract themes and icon sets and roughly a thousand functional extensions remain. The VS Code extension marketplace is larger by orders of magnitude, and that is a hard difference no configuration works around.

The technical model also differs from VS Code. An extension is a Git repository with an extension.toml manifest. The procedural part, if one is needed at all, is written in Rust and compiled for the wasm32-wasip2 target, meaning it runs inside a WebAssembly sandbox. The documentation notes that most extensions contain no Rust code at all, because themes, syntax, snippets and basic language support are described declaratively.

id = "my-extension"
name = "My extension"
version = "0.0.1"
schema_version = 1
authors = ["Your Name <you@example.com>"]
description = "Example extension"
repository = "https://github.com/your-name/my-zed-extension"

[language_servers.vscode-html-language-server]
name = "vscode-html-language-server"
language = "HTML"

[grammars.html]
repository = "https://github.com/tree-sitter/tree-sitter-html"
commit = "bfa075d83c6b97cd48440b3829ab8d24a2319809"

The manifest describes what the extension provides. The documentation lists languages, debug adapters, themes, icon themes, snippets and MCP servers, while separate chapters cover slash commands and agent servers. What is absent from that list is any arbitrary interface view. An extension will not paint its own panel or its own visualisation, which cuts off a whole category of plugins familiar from VS Code.

Extension permissions are granted explicitly and can be narrowed. Three are granted by default: running processes, downloading files and installing npm packages, each with a pattern that allows everything.

{
  "auto_install_extensions": { "html": true },
  "granted_extension_capabilities": [
    { "kind": "process:exec", "command": "*", "args": ["**"] },
    { "kind": "download_file", "host": "github.com", "path": ["**"] },
    { "kind": "npm:install", "package": "*" }
  ]
}

Setting an empty list takes everything away from extensions and, as the documentation warns, usually renders most of them non-functional. Narrowing the download host to github.com, as above, is a sensible compromise in a company with a supply chain security policy.

Agent features, accounts and pricing

Zed carries two layers of language model features, and confusing them leads to bad decisions about cost.

The first is edit prediction, meaning multi-line suggestions inserted with the tab key. The default provider is Zeta, an open model developed by Zed Industries, with GitHub Copilot, Codestral and Mercury Coder as alternatives. The second is the agent panel, running either Zed's own agent with company-hosted models or an external agent attached through the Agent Client Protocol. In that second role the documentation lists Claude, Codex, OpenCode, Copilot and Cursor among others, and Zed charges nothing for external agents, because you settle directly with their provider. That is a different arrangement from Cline or Continue, where the extension is itself an agent inside somebody else's editor.

The pricing on the vendor's page has three tiers. The Personal plan costs zero and gives the full editor, except that edit predictions are capped at 2000 accepted suggestions per month. Your own keys to model providers and external agents work on that plan without limits. The Pro plan costs 10 dollars a month, removes the suggestion cap and includes 5 dollars of token credit, with usage above that amount billed at the provider's list price plus 10 percent. The Business plan costs 30 dollars per seat per month and adds an administrative layer: organisation-wide model policies, a lock on data sharing settings and unified billing.

Three items in the pricing deserve a careful read. Business seats carry no bundled token credit allotment, so model usage costs come on top. Single sign-on in the SAML and SCIM standards is described as planned rather than available, which settles the matter for some organisations. The vendor also states two different credit amounts: the plan page says 5 dollars on the Pro subscription while the description of the two-week trial says 20 dollars, so these are two separate pools rather than one figure.

Multiplayer mode is a separate feature and requires signing in. Channels and private calls let you edit a project together and talk over voice. The documentation attaches a warning that is easy to miss: sharing a project gives collaborators access to your file system within that project.

Zed against the alternatives

The choice comes down to one question: how much of your daily work depends on specific extensions. If you run five plugins in VS Code and none of them paints its own panel, moving to Zed is an afternoon's work and you gain a noticeably shorter editor response time. If you run thirty plugins, some of them in-house, moving means rewriting them or giving up part of the work. If the agent is your main reason, check first whether your agent speaks the Agent Client Protocol, because then you get it inside Zed without switching provider and without a double subscription.

Common mistakes

The first is treating the repository as a project under a single permissive licence. If your company keeps a licence list, recording NOASSERTION from GitHub says nothing, and recording Apache 2.0 alone is simply untrue. The correct entry is GPL-3.0-or-later for the editor and Apache 2.0 for the marked libraries.

The second is assuming that because GPUI is under Apache 2.0, a fork of the editor may also be closed. The editor module and its neighbours carry GPL-3.0-or-later in their manifests, and distributing a modified editor falls under that licence regardless of some dependencies being permissive.

The third is installing on a machine without graphics acceleration. On Linux the official release expects a Vulkan-compatible card, and on a server without one or on an old distribution with glibc below 2.31 building from source is the only route.

The fourth is trying to use Windows as a remote server. Windows is supported as the local machine, but Zed's headless server runs today only on macOS and Linux.

The fifth is leaving the default extension permissions in place in an environment with a security policy. By default every extension may run any command, download a file from any host and install any npm package. Narrowing the granted_extension_capabilities list takes a minute.

The sixth is installing zed_extension_api at the number seen in the release sources. The repository says 0.8.0 while crates.io publishes 0.7.0, and that is the version that lands in your project.

The seventh is counting on the Business plan as a finished enterprise layer. Administrative control covers Zed-hosted services, and single sign-on in the SAML and SCIM standards is not there yet.

FAQ

What licence is Zed under?

Two at once, depending on the directory. The editor and the collaboration server sit on GPL-3.0-or-later, while the libraries meant for use outside the editor, including GPUI and the extension interface, sit on Apache 2.0. In release 1.16.1 the Cargo manifests declare GPL-3.0-or-later 206 times and Apache-2.0 34 times.

Does Zed use the AGPL licence anywhere?

Not in release 1.16.1. There is no AGPL licence file in the tree and no manifest with such a field, and the dependency licence policy file carries a comment stating plainly that AGPL is not to be added to the accepted list.

Does Zed work on Windows the same as on macOS?

For local work yes, there is one stable release for all three systems and a winget package. The difference concerns remote work: Zed's headless server runs on macOS from Catalina onwards and on Linux, while Windows can only be the local machine.

Can I write an extension in JavaScript?

No. The procedural part of an extension is written in Rust and compiled to WebAssembly for the wasm32-wasip2 target. Themes, snippets and basic language support are described declaratively and need no code at all.

Is Zed free?

The editor itself is, the Personal plan costs zero and does not limit editing features. What costs money are the company-hosted language model features: the Pro plan at 10 dollars a month and the Business plan at 30 dollars per seat per month. Your own keys to model providers work on the free plan as well.

How many extensions does Zed have?

The registry holds 1441 entries, of which 429 are themes and 24 are icon sets. That leaves roughly a thousand functional extensions, orders of magnitude fewer than on the VS Code extension marketplace.

The documentation lives on the Zed site, the source code in the GitHub repository, and the agent protocol specification on the Agent Client Protocol site.