Your code editor sees everything. Every file you open. Every line you write. Every project you work on. Every search you run. Every terminal command you execute. If any tool on your machine has a complete picture of your work, it is your code editor.

Most popular code editors are built on browser engines. They bundle an entire rendering stack designed for web pages just to display text. That means hundreds of megabytes of RAM consumed before you open a single file. It means your editor’s performance ceiling is determined by how fast a browser can draw text. And in many cases, it means telemetry enabled by default, reporting your usage patterns, extension installs, and error data back to the company that ships the editor.

Stripping telemetry from a browser-based editor helps. But the architecture underneath was never designed for you. The resource consumption stays. The dependency on someone else’s rendering engine stays. The foundation does not change.

What to Look For in a Clean Editor

If you are serious about controlling your tools, here is what a code editor should provide:

  • No telemetry by default. The editor should not phone home unless you explicitly opt in. Not an opt-out toggle buried in settings. No telemetry in the binary unless you turn it on.
  • Open source. The entire application. Not an open source base with proprietary additions layered on top. Actually open source. Readable, buildable, auditable.
  • Native rendering. A code editor should not need a browser engine to render text. Native performance matters. Memory consumption matters. Startup time matters. These are not luxuries. They are the baseline.
  • No vendor lock-in. Your settings, your extensions, your workflow should not depend on one company’s ecosystem. If the company goes under, gets acquired, or changes direction, your editor should still work.
  • Auditable network behavior. You should be able to run a packet capture on your machine and see exactly zero outbound connections from your editor when you are not explicitly using an online feature. If you cannot verify it yourself, the promise is meaningless.

Zed

Zed is not a fork. It is not a wrapper. It is not a reskin of someone else’s project. It is written from scratch in Rust. Native GPU rendering through their own framework called GPUI. No browser engine in the rendering pipeline. The editor talks directly to your GPU to draw text. The difference in performance is not incremental. It is a different category.

Startup is near-instant. Memory consumption is minimal. File operations are fast because they are not going through a JavaScript runtime and a browser engine to reach the filesystem. The editor feels like a tool built for the machine it runs on, because it is.

Zed is open source under a dual GPL/AGPL license. The code is on GitHub. You can read it. You can build it. You can audit exactly what it does on your machine. There is no proprietary layer on top. There is no "community edition" with missing features. The editor you download is the editor they develop.

Disable Telemetry on First Launch

Zed does include optional telemetry and crash reporting. It is straightforward to disable and the editor respects the setting. On first launch, open your settings file:

macOS: Cmd+, or Zed > Settings > Open Settings

Linux: Ctrl+,

Add this block to your settings.json:

{
  "telemetry": {
    "diagnostics": false,
    "metrics": false
  }
}

That is it. Two settings. Diagnostics controls crash reporting. Metrics controls usage analytics. Set both to false and Zed sends nothing. No buried toggles. No trust required that a binary you did not compile will honor a setting. The code that checks these values is open source. You can read the implementation yourself.

Verify It Yourself

Do not take anyone’s word for it. Including ours. Run your own network monitoring and see what Zed actually does on your machine.

On macOS, open a terminal and run:

# Watch all network connections made by Zed
sudo lsof -i -n -P | grep -i zed

Or for continuous monitoring:

# Log all DNS lookups from Zed
sudo tcpdump -i any -n port 53 2>/dev/null | grep --line-buffered zed

With telemetry disabled and no collaborative features active, Zed should make zero outbound connections while you edit code. If you see connections you do not expect, you have the source code to figure out why. That is the difference between a tool you control and a tool that controls you.

For a more thorough audit, use a tool like Little Snitch or Lulu on macOS. These are application-level firewalls that show every outbound connection attempt from every process on your machine. Run Zed with telemetry disabled and watch. You should see nothing. If you see something, block it and investigate.

The Cross-Platform Path

Zed runs on macOS and Linux. The Linux version reached stable in early 2025 and is actively developed. Same editor. Same configuration. Same settings file. Your settings.json and keybindings work on both platforms.

This matters because the endgame for a lot of developers on this blog is Linux. If you are moving to Linux, your editor should come with you. Zed does. Your configuration is a JSON file in a known location. Copy it to a new machine and you have your editor. No account sync. No cloud service. No dependency on a company’s infrastructure to move your own settings to your own machine.

On Linux, install via the official script:

curl -f https://zed.dev/install.sh | sh

Or through your package manager if your distribution has packaged it. The settings file lives at ~/.config/zed/settings.json. Same format. Same options. Same telemetry block to add on first launch.

The Principle

The tools you build with should not be built against you. Browser-based editors burn resources to render what should be the lightest interface on your machine. Many of them report your work back to the companies that ship them.

Zed is what a code editor looks like when you start clean. Native. Fast. Open source. No telemetry by default. Verifiable on your own network. Portable across the platforms that matter.

Your editor sees every line of code you write. Make sure it answers to you and nobody else.