Void Editor is dead. The GitHub repository was archived on June 2, 2026 — the team posted a brief farewell, set the repo to read-only, and stopped accepting contributions. It never shipped a stable v1.0.

That’s the bad news. Here’s why it matters anyway: Void was the only editor that proved a privacy-first, open-source, direct-to-provider AI coding tool could actually work. The architecture held. The features shipped. The concept was validated. And then, two days before this article was written, it closed.

If you were evaluating Void as a Cursor replacement, the answer is now: don’t. Use Cursor. But understanding what Void built — and why it made different tradeoffs than Cursor — is worth your time, because those tradeoffs still matter and the debate hasn’t gone away.

Who this is for

Developers who care about where their code goes when they ask an AI to touch it. Specifically: teams under audit, contractors whose clients prohibit SaaS data routing, OSS contributors who want to self-host their toolchain, or anyone who’s read a reverse-engineering thread about Cursor’s infra and felt uneasy.

If none of that describes you, skip this and go read Cursor vs Claude Code.

The architecture that made Void different

Every mainstream AI editor — Cursor, Windsurf, GitHub Copilot — routes your LLM requests through its own backend. Cursor’s own documentation states it: “all requests are routed through Cursor’s servers for final prompt building” — this applies even when you supply your own API key. That’s not a bug; it’s how they build shared features, telemetry, and context caching. But it means your code leaves your machine in a hop you don’t control.

Void’s architectural choice was different by design. LLM calls ran from your machine directly to the API endpoint of your chosen provider — no Void relay, no Void backend, nothing in between. The call was made from the Electron main process (not the renderer) specifically to avoid browser-context CORS and CSP restrictions, particularly relevant when connecting to local HTTP providers like Ollama. The code was — and remains — publicly inspectable at github.com/voideditor/void. No credible audit disputed the direct-to-provider claim during the project’s lifetime.

Cursor offers Privacy Mode at every tier — free, Pro, Teams, and Enterprise. It’s on by default for team members. What Privacy Mode controls is data retention and model training, not routing. Traffic still passes through Cursor’s servers in Privacy Mode; the routing does not change. Void’s privacy was different in kind: no Void relay existed at all. Direct-to-provider was the only mode, for every user, on the free Apache-2.0 license.

Setup and first impressions

Void is a VS Code fork. If you’ve used VS Code, the transition was frictionless: same extension marketplace, same keyboard shortcuts, same settings.json structure. Install was a standard binary download for macOS, Windows, and Linux.

Model connection happened in a dedicated sidebar panel. You added providers (Anthropic, OpenAI, Ollama, etc.) with API keys or local endpoint URLs, then selected the active model per context. First-run experience was rougher than Cursor — no guided setup wizard, no defaults that worked without manual configuration — but once configured it behaved as expected.

VS Code extension compatibility was high (Void is a fork, not a plugin), but Void inherited the same Microsoft extension restrictions that Cursor faces: Pylance, C# Dev Kit, and ms-vscode.cpptools were blocked. Python and C# developers hit this immediately.

AI features

Void’s feature set at deprecation was meaningfully complete for a pre-1.0 product.

Ctrl+K inline edits

Inline edit via Ctrl+K was the primary quick-edit flow. You selected code, hit the shortcut, typed a natural-language instruction, and Void generated a diff. The implementation used FIM (fill-in-the-middle) prompting and plugged directly into VS Code’s codebase — not an extension API layer. This shipped in v1.0.0 (January 2025) and was the most polished feature throughout the project’s life.

Agent mode

Agent mode landed in v1.0.2 (March 2025). It gave the LLM the ability to read and write files, run terminal commands, and search the codebase. That’s the right minimal set for a coding agent — read context, write changes, run tests. Not as sophisticated as Cursor Composer 2’s parallel execution, but functionally useful for single-threaded agentic tasks. Local OSS models (via Ollama, vLLM) gained full agent mode support in v1.2.1 (April 2025).

Checkpoints (also v1.2.1) added snapshot-and-restore for agent sessions — a safety net before destructive operations. Useful, though reliability was community-reported as inconsistent.

Apply modes: Fast and Slow

Two diff application strategies:

Fast Apply: search/replace block diffs for targeted, surgical edits.
Slow Apply: full file rewrite for larger changes or when the model’s targeting was uncertain.

The distinction was explicit in the UI and matched practical use — Fast Apply for small changes, Slow Apply when the model needed to reason about the whole file.

DiffZone

Accept/Reject per hunk, rendered as red/green diffs in the editor gutter. Standard for modern AI editors, implemented cleanly. The code defined this as the “DiffZone” component in VOID_CODEBASE_GUIDE.md.

Chat and Gather modes

Void separated chat from action: Gather mode assembled multi-file context without taking action; Chat mode was the conversational interface for reasoning about that context before acting. The separation kept “explore the codebase” workflows distinct from “change the codebase” workflows — a design choice that made the tool more predictable in agentic use.

MCP support

Model Context Protocol support landed in v1.4.1 (June 5, 2025) — the same release that added Claude 4, Azure OpenAI support, and AI-generated commit messages. MCP is increasingly the protocol for extending AI coding tools with external context. Getting it in before the repo was archived gave Void a solid final feature set.

Model flexibility

This is where Void pulled furthest ahead of Cursor.

Cloud providers

All connections used your API key. Void never touched the traffic.

Version	Models added
v1.0.0 (Jan 2025)	Anthropic, OpenAI
v1.0.2 (Mar 2025)	Claude 3.7, Gemini 2.0
v1.2.1 (Apr 2025)	GPT-4.1, Gemini 2.5 Pro
v1.2.4 (Apr 2025)	o3, o4-mini
v1.4.1 (Jun 2025)	Claude 4, Azure OpenAI

The final supported frontier models were Claude 4, GPT-4.1/o3/o4-mini, Gemini 2.5 Pro, Grok 3, DeepSeek, Mistral, and Azure OpenAI — a broader selection than Cursor’s native model list.

Local and self-hosted models

Cursor has no local model support. Void had four options out of the box:

Provider	Default endpoint
Ollama	http://127.0.0.1:11434
vLLM	http://localhost:8000
LM Studio	http://localhost:1234
Any OpenAI-compatible	User-configured

Ollama support wasn’t an afterthought — it was a foundational PR (#22) merged October 2, 2024, one day after the initial early launch. If you wanted to run Llama 3.1 70B locally with Void as the editor frontend, that was a real, supported workflow. Not fast (local hardware constraints apply), but real.

Limitations and rough edges

Pre-1.0 throughout: v1.0.0 was labeled beta. The project never shipped a stable release by its own versioning. Autocomplete reliability, agent session stability, and Apply diff quality were community-reported as inconsistent throughout the lifecycle. Promising foundation; needed more iteration it never got.

No performance benchmarks: There are no independent latency or acceptance-rate comparisons between Void and Cursor in the primary sources. The architectural privacy win is verifiable. The quality delta — whether Void’s agent mode was meaningfully worse, on par, or comparable at specific tasks — is not. Anyone who tells you otherwise is speculating.

Frozen: No security patches. No model updates for models released after mid-2025. No bug fixes. The codebase will drift from API compatibility as providers make breaking changes.

Extension gaps: Python (Pylance), C#, and C/C++ developers hit the same Microsoft-imposed extension restrictions as Cursor users. VS Code fork, same limitations.

Where Void won, where Cursor won

Dimension	Void	Cursor
Privacy	Direct-to-provider; open-source inspectable	Routes through AWS even with own API key
Cost	Free (pay API only)	$20–40/month subscription
Local models	Ollama, vLLM, LM Studio	None
Open source	Apache-2.0	Proprietary
Active development	Deprecated June 2026	Active
Tab autocomplete quality	Inconsistent	Best available
Agent mode maturity	Functional; rough edges	Composer 2; production-grade
Stability	Pre-1.0; beta throughout	Production-grade
Extension ecosystem	~VS Code parity	~VS Code parity

Persona fit (historical framing)

Given deprecation, these are “who should have used Void” categories — useful because the problem each persona faces hasn’t gone away.

Hobbyist / OSS contributor: Void was a strong fit. Free, open-source, connects to your own API keys, runs local models. If you were experimenting with AI coding on a budget and Cursor’s $20/month felt like too much before you knew you’d stick with it, Void was worth trying.

Enterprise under privacy/compliance requirements: Void was the only realistic option among IDE-based tools. The direct-to-provider architecture and open-source codebase made it auditable in a way Cursor is not. That audience still exists. Void is no longer a viable answer for them.

Power user chasing maximum AI quality: Cursor was the better choice while Void was alive, and it remains the better choice now. Void’s agent reliability was behind Cursor Composer, and the lack of a dedicated autocomplete model was a real daily-driver gap. Our Cursor 2026 review covers the current state in detail.

Verdict

Void won the argument it was trying to make. Open-source, direct-to-provider AI coding tools are buildable. Local model support in an IDE-native editor is feasible. Privacy doesn’t have to be a paid-tier feature. The proof of concept worked.

The project also showed the execution difficulty: building and maintaining a full VS Code fork with competitive AI features against a well-funded closed-source competitor is hard. The team couldn’t sustain it.

If you want privacy-first AI coding today: there is no clean replacement. Void’s GitHub repo notes it’s “one of the best references to use when forking VS Code” — a hint that community forks may emerge. Watch the archived repo’s network graph for active forks with momentum. Nothing has pulled ahead yet.

If you want a production-grade AI editor today: Cursor is the benchmark. It routes through AWS, costs $20/month, and its privacy story requires trust in a closed system. It is also significantly more polished, actively developed, and has better tab autocomplete than anything else in the market. The deprecation of Void actually makes this recommendation simpler, not harder: Void was the best argument for an alternative path, and that path is now unmaintained.

For local model hosting on GPU cloud (Ollama/vLLM on a rented A100), Runpod and Modal are the practical options — cloud GPU inference without running local hardware.

References

Void Editor GitHub (archived) — Apache-2.0, read-only as of June 2, 2026
Void Changelog — version-pinned feature timeline
VOID_CODEBASE_GUIDE.md — DiffZone, Apply modes
deepwiki: Void getting started — local endpoint URLs, architecture confirmation
Cursor: Bring your own API key — confirms all requests route through Cursor’s servers even with own key
Cursor: Security & Privacy — “Privacy Mode is available to anyone (free or Pro) and is enabled by default for members of a team”
Speedscale: Peeking under the hood of Cursor — API call analysis
HN: Void Editor (thread 1)
HN: Void Editor (thread 2)
InfoQ: Void IDE beta release