What Is Void Editor? (The Open-Source Cursor Fork Explained)

Void Editor is an MIT/Apache 2.0 licensed fork of VS Code, built by Y Combinator–backed co-founders Andrew Pareles and Mathew Pareles. Launched in September 2024, Void reached 28,800 GitHub stars and 2,500 forks by May 2026 — making it one of the fastest-growing open-source AI IDE projects ever. Unlike Cursor or Windsurf, which run proprietary backends that your code passes through, Void connects directly from the editor to your chosen AI provider: Anthropic, OpenAI, Google Gemini, DeepSeek, or a local Ollama instance. The project had 46 contributors and 2,771 commits in its active phase. In January 2026, development was officially paused while the team explored “novel coding ideas” beyond feature parity with Cursor — a critical fact every prospective user must weigh before adopting Void for production workflows.

Void entered beta publicly in June 2025, generating a Hacker News submission with 948 points and 343 comments. The enthusiastic response reflected pent-up demand for a privacy-respecting Cursor alternative that was also completely free. As one commenter put it: “If you’ve ever had to answer where does our source code go in a security review, this is the shortest answer in the category.” Void’s architecture is 95.3% TypeScript, meaning any developer comfortable with the VS Code extension ecosystem can read, fork, or modify the source with minimal friction. The editor runs on macOS, Windows, and Linux, preserving the same cross-platform support as VS Code and Cursor.

Void Editor Key Features in 2026

Void Editor ships several capabilities that mirror — and in a few cases exceed — what Cursor offers, all within an open-source, zero-subscription model. The editor’s feature set focuses on transparent, inspectable AI interactions rather than opaque cloud orchestration. You pay only your own API costs; Void itself is free.

Gather Mode is Void’s most distinctive feature and one that Cursor does not offer. It lets an AI agent scan your entire codebase in read-only mode — building context, mapping dependencies, understanding architecture — without making any file changes. This is valuable for large codebases where you want AI-assisted analysis before committing to any edits, particularly useful during onboarding or debugging.

Checkpoints automatically snapshot every AI-driven file modification. Unlike Git stashes or manual undo, checkpoints are granular and automatic: each time the AI modifies a file, Void stores a rollback point. This gives you a detailed undo history without manual ceremony.

Fast Apply uses structured patch application rather than regenerating entire files. When the AI modifies a function, Void sends targeted diffs rather than requesting a full file rewrite — faster, cheaper in tokens, and less prone to accidental overwrites.

Prompt Inspection lets you view and edit the exact prompt sent to the AI provider before or after each request. This level of transparency is rare in commercial AI editors and invaluable for debugging AI behavior, optimizing token usage, or understanding why a response went wrong.

Bring-your-own-API-key architecture means you can use Anthropic Claude, OpenAI GPT-4o, Google Gemini 1.5 Pro, xAI Grok, OpenRouter, DeepSeek API, or Qwen API — switching freely between providers without subscriptions.

Local Model Support: Running Ollama, DeepSeek, and Llama Locally

Void Editor’s local model support is its most compelling differentiator for privacy-sensitive teams and air-gapped environments. By integrating with Ollama, vLLM, LM Studio, and any OpenAI-compatible endpoint, Void enables 100% offline AI coding — no data ever leaves your machine. This architecture makes Void viable for defense contractors, healthcare systems, financial institutions, and any team operating under strict data-residency rules that disqualify cloud AI editors entirely.

Setting up local models takes under five minutes with Ollama. Install Ollama, pull a model (ollama pull deepseek-coder-v2 or ollama pull llama3.1:8b), then point Void at http://localhost:11434 in settings. Void’s OpenAI-compatible endpoint support means any model served by LM Studio or a custom vLLM instance works identically. For FIM (Fill-in-the-Middle) autocomplete, Void supports the correct API shape, though local model quality for autocomplete varies significantly by model size.

Recommended models by hardware tier (2026):

The hardware reality is significant. Running Qwen 2.5 14B or DeepSeek Coder V2 at acceptable latency requires a GPU with 16GB+ VRAM. On CPU-only hardware, responses take 15–60 seconds per generation, making agent mode practically unusable. As one early reviewer noted: “You have to have a pretty damn good machine to run Qwen 2.5 14B. If you don’t have a 4080, it’s going to be dog slow.” For teams without qualifying hardware, Void’s local model story collapses back to “just use your own API key” — still private, but no longer offline.

Void Editor vs Cursor: Head-to-Head Feature Comparison

Cursor dominates the commercial AI IDE market with approximately 800,000 monthly active users in 2026. It acquired Supermaven in November 2024, adding ~250ms autocomplete latency. Cursor Pro costs €18/month; Pro+ reaches €55/month. Void is free — you pay only your API provider costs, which for moderate use often runs €5–15/month via direct API, cheaper than any Cursor tier.

The core tradeoff: Cursor is a fully-supported, rapidly evolving commercial product with unique latency-optimized completions and enterprise features. Void is a transparent, free, privacy-first tool that was highly capable at its last release but is no longer actively maintained.

For indie developers, researchers, and privacy-conscious teams using their own API keys, Void often delivers 80% of Cursor’s value at 0% of its subscription cost. For teams needing documentation indexing, background agents, BugBot, or commercial SLAs, Cursor is the clear choice.

Void Editor vs Other Open-Source Alternatives (Cline, Continue, Zed)

Void is one of several open-source paths to AI-assisted coding, but each alternative has a different architecture and maturity profile. Understanding where Void sits in the broader open-source AI IDE landscape is critical for making the right choice.

Cline (formerly Claude Dev) is a VS Code extension rather than a standalone fork. It runs inside your existing VS Code installation, meaning you keep your existing configuration, extensions, and keybindings. Cline supports the same bring-your-own-API-key model as Void and has significantly more active development in 2026. For developers who don’t want to maintain a separate IDE installation, Cline is often the pragmatic choice.

Continue is another VS Code/JetBrains extension with robust local model support via Ollama. It focuses on configurability — custom system prompts, multiple model configs per context window, slash commands — and has a strong open-source community. Continue lacks Void’s polished Cursor-like UX but excels in customizability.

Zed is a ground-up rewrite in Rust, not a VS Code fork. It offers exceptional performance (50–100ms keystroke latency is common) and built-in AI features, but the extension ecosystem is far smaller than VS Code’s. Zed is best for developers willing to trade ecosystem breadth for raw speed.

If active maintenance is a hard requirement, Cline or Continue are safer open-source choices than Void in 2026. If you specifically want a Cursor-like standalone IDE experience with full UI polish, Void’s v1.4.9 release remains a functional and valid option.

Privacy and Data Control: Why Void’s Architecture Is Different

Void’s privacy architecture is not a marketing claim — it is a structural property of how the editor works. Every AI request flows directly from the editor process on your machine to the API endpoint you configure. There is no Void backend, no telemetry pipeline, no model-training data collection. The code path from your editor to Claude or GPT-4 is as direct as a curl command.

This stands in contrast to Cursor’s architecture, where code is sent to Cursor’s servers before being forwarded to AI providers. Cursor’s privacy policy acknowledges this routing and offers enterprise plans with stronger guarantees, but the baseline is that your code transits Cursor’s infrastructure. For regulated industries — healthcare (HIPAA), finance (SOX, FINRA), defense (ITAR/EAR), or any organization subject to GDPR data-residency requirements — this distinction can be the difference between a tool that passes security review and one that doesn’t.

Void’s MIT/Apache 2.0 dual license enables additional assurances: organizations can audit the source code, verify the network behavior with Wireshark or a proxy, and fork the codebase to apply custom security patches. This level of auditability is impossible with Cursor or Windsurf. One security engineer’s framing captures it well: “If you’ve ever had to answer ‘where does our source code go?’ in a security review, Void is the shortest answer in the category.” The direct-to-provider model also means you retain full control over which AI providers are approved — simply don’t configure providers that aren’t on your organization’s approved vendor list.

The January 2026 Development Pause: What It Means for Users

On January 12, 2026, Void’s co-founders posted a statement to the GitHub repository: “We’ve paused work on the Void IDE to explore a few novel coding ideas. We want to focus on innovation over feature-parity.” The last release, v1.4.9, was published on June 23, 2025. The official website now shows: “Work on Void is currently paused. Some features may be outdated or broken.”

This pause is the most important fact about Void in 2026, and how much it matters depends entirely on your use case.

What the pause means in practice:

• No security patches for newly discovered vulnerabilities in the VS Code base Void forked
• No compatibility updates when macOS, Windows, or Linux make breaking changes
• No fixes for bugs reported after January 2026
• The gap between Void’s VS Code base and the current VS Code release will widen over time

What the pause does NOT mean:

• Void v1.4.9 stops working tomorrow — it will continue functioning indefinitely for most users
• The codebase disappears — it remains MIT/Apache 2.0 licensed and publicly forkable
• Community forks are impossible — independent developers can and do maintain their own builds

Risk assessment by team type:

The YC-backed founding team paused rather than shut down, and the repository remains public. A community fork or new investment round could restart development. Until that happens, treat Void as mature open-source software in maintenance mode — not abandoned, but not evolving.

Performance and Hardware Requirements for Local Models

Running AI models locally through Void produces wildly different experiences depending on your hardware. Cloud-based providers (Anthropic, OpenAI) deliver consistent latency regardless of your machine — typically 1–5 seconds for inline edits and 10–30 seconds for agent tasks. Local models depend entirely on your GPU/CPU and the model size you choose.

Token generation speed benchmarks (approximate, 2026):

At 120 tokens/second, Llama 3.1 8B on an RTX 4090 feels snappy for inline edits. At 8 tokens/second on CPU, even simple completions feel painfully slow. The practical minimum for a usable agent mode experience is ~40 tokens/second — achievable on an RTX 4080 or Apple M2 Pro with an 8B model, or on an M3 Max with a 16B model.

Memory requirements are the binding constraint. A 7B model requires ~6GB VRAM at 4-bit quantization; a 14B model needs ~10GB; a 32B model needs ~20GB. Models that don’t fit in VRAM spill to RAM, dropping performance by 5–20x. Ollama handles quantization automatically, but choosing the right model size for your hardware is essential.

For teams where most developers lack qualifying hardware, Void’s local model promise is best realized on dedicated inference servers — a single powerful machine running Ollama that team members point their Void installations at via local network. This architecture preserves the privacy guarantee (code stays on-premises) while making the hardware cost a shared infrastructure investment rather than per-developer.

How to Get Started with Void Editor

Getting Void running takes about 10 minutes. Download the latest release (v1.4.9) from the GitHub releases page, install it like any desktop application, and configure your first AI provider.

Step 1 — Install Void: Download the appropriate package for your OS from github.com/voideditor/void/releases/tag/v1.4.9. macOS users get a .dmg; Windows users get a .exe installer; Linux users can choose .deb, .rpm, or .AppImage.

Step 2 — Configure a cloud provider (quickest path): Open Settings (Cmd/Ctrl + ,), navigate to the Void AI section, and add your provider API key. Paste your Anthropic or OpenAI API key. Select your default model. You’re ready to use AI features immediately.

Step 3 — Configure Ollama for local models (optional):

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.ai/install.sh | sh

# Pull a coding-optimized model
ollama pull deepseek-coder-v2

# Ollama serves at localhost:11434 by default

In Void settings, add a new provider: type Ollama, URL http://localhost:11434, model name matching what you pulled. Test with a simple question.

Step 4 — Try Gather Mode: Open the command palette (Cmd/Ctrl + Shift + P), type “Void: Gather”, and let the agent scan your codebase in read-only mode. Ask it to explain the architecture or identify potential bugs — without touching any files.

Step 5 — Explore Checkpoints: Make an AI-driven edit using inline mode (Cmd/Ctrl + K). After the edit, open the Void Checkpoints panel to see the automatic rollback point. This is your safety net for any AI-generated changes.

Since Void is a VS Code fork, your existing .vscode/settings.json, extensions (most VS Code extensions work in Void), and keybindings transfer with minimal adjustment. Teams migrating from VS Code will feel at home immediately.

Who Should Use Void Editor in 2026?

Void Editor is the right tool for a specific set of developers and teams — and the wrong tool for others. The development pause makes the use-case fit more important than ever.

Void is the best choice if you:

• Are an indie developer or solo freelancer who wants Cursor-like AI features at zero subscription cost
• Work with client code under NDA and cannot route source to third-party servers
• Are building in a regulated industry (healthcare, finance, defense) where data residency rules disqualify cloud AI editors
• Have qualifying hardware (RTX 4080+, M2 Pro+) and want fully offline AI coding
• Are a privacy researcher or security engineer who needs full auditability of your toolchain
• Want to inspect, fork, or extend your AI editor’s source code
• Are evaluating open-source AI editors for a research project or academic context

Void is NOT the right choice if you:

• Need active commercial support with SLAs
• Depend on documentation indexing (Cursor indexes API docs via URL crawling)
• Use Background Agents or Cursor’s BugBot for async PR review
• Work in a large enterprise team that needs centralized audit logs and access controls
• Are on CPU-only hardware and want local models (the performance is unusable)
• Need the absolute lowest autocomplete latency (Cursor’s Supermaven-powered completions at ~250ms are unmatched)

For teams that need an open-source path but want active maintenance, Cline (VS Code extension) or Continue are better alternatives today. Both support local models via Ollama, both have active development, and both preserve the VS Code extension ecosystem without requiring a separate IDE install.

Final Verdict: Is Void Editor Still Worth It?

Void Editor is one of the most important proofs-of-concept in the open-source AI IDE space — demonstrating that a Cursor-quality experience is architecturally possible without a proprietary backend, a subscription model, or code leaving your infrastructure. Its 28,800 GitHub stars, clean MIT/Apache 2.0 license, and YC pedigree reflect a project that briefly achieved something genuinely impressive.

The January 2026 development pause changes the calculus significantly. Void v1.4.9 is functional software and will remain functional for most users through 2026. But it is frozen in time — accumulating technical debt against VS Code’s base, unable to add the Background Agents or documentation indexing that widen Cursor’s competitive moat each month.

Final rating by use case:

The bottom line: if your primary concern is privacy, cost, or data control, Void Editor v1.4.9 delivers real value today. If you need active maintenance, enterprise features, or the fastest possible autocomplete, Cursor or an actively maintained open-source alternative is the more responsible choice. The open-source AI IDE war is not over — Void’s story may not be either.

FAQ

Is Void Editor free? Yes. Void is completely free under MIT/Apache 2.0 license. You pay only for the AI provider API calls you make — no subscription to Void itself. For light users making a few hundred AI requests per month, direct API costs are typically $3–15, often cheaper than Cursor’s €18/month Pro tier.

Is Void Editor still being developed? Development was officially paused on January 12, 2026. The last release is v1.4.9 from June 23, 2025. The official website notes that “work on Void is currently paused” and “some features may be outdated or broken.” The team indicated they are exploring “novel coding ideas” beyond feature parity with Cursor. The repository remains public and forkable.

Can Void Editor use local models like Ollama? Yes. Void supports Ollama, vLLM, LM Studio, and any OpenAI-compatible local endpoint. This enables 100% offline AI coding with no data leaving your machine. For practical usability, you need at least an RTX 4080 or Apple M2 Pro for 8B models; smaller or older GPUs will produce unusably slow generation speeds.

How does Void Editor compare to Cursor in 2026? Void is free and privacy-first; Cursor costs €18–55/month and routes code through its backend. Cursor leads on active development, autocomplete latency (~250ms via Supermaven), documentation indexing, Background Agents, and BugBot. Void leads on privacy, cost, local model support, Gather Mode (read-only agent), and source code transparency. For developers where privacy and cost are paramount, Void is often the better choice.

What happened to Void Editor’s development? Co-founders Andrew and Mathew Pareles paused development in January 2026 to explore “novel coding ideas” beyond building Cursor feature parity. The YC-backed project grew rapidly — 948 Hacker News points, 28,800 GitHub stars — but the team chose to pivot rather than continue incrementally matching Cursor’s commercial roadmap. The codebase remains open source and community forks are possible.