Void Editor Banner

Look, We Need to Talk About Cursor’s Pricing Problem

I like Cursor. I really do. The tab completion is magic, the chat understands my codebase, and the “Ctrl+K” inline editing is genuinely useful. But $20/month? For something that’s basically a VS Code fork with some LLM API calls bolted on? That’s $240/year — for each developer on your team.

And then there’s the privacy issue. You’re sending your proprietary code to Cursor’s servers (yes, even with the “privacy mode” — do you really trust them?). And it’s closed-source, so who knows what’s actually happening with your data?

Enter Void Editor. It’s an open-source, Cursor-compatible code editor that:

  • Costs $0 (as in, free beer and free speech)
  • Is 100% open-source (AGPL license, fork it all you want)
  • Works with your own API keys (OpenAI, Anthropic, Ollama, whatever)
  • Has zero telemetry by default
  • Is basically Cursor, but without the $20/month “tax”

I’ve been using it for 3 weeks. I haven’t looked back. Also, my credit card is happier.

What Is Void Editor, Exactly?

Void Editor is a fork of VS Code (just like Cursor is) with AI coding features built in. But unlike Cursor, it’s:

  1. 100% open-source — the entire codebase is on GitHub (AGPLv3 license). You can read every line of code, fork it, self-host it, modify it, whatever.
  2. Bring Your Own Key (BYOK) — you provide your own LLM API keys (OpenAI, Anthropic, OpenRouter, Ollama, etc.). No middleman, no markup, no $20/month subscription.
  3. Privacy-first — no telemetry, no data collection, no “we store your code to improve our model” nonsense. Your code stays on your machine (or goes directly to the LLM API you configure).
  4. Community-driven — features are prioritized by the community, not by a VC-backed startup trying to maximize ARR.

As of May 2026, Void has 25,000+ GitHub stars and a rapidly growing community. It’s not as polished as Cursor yet, but it’s improving fast — and it’s free.

The Features (That Actually Matter, Unlike “AI-Powered Code Review” That Just Says “Looks Good!”)

Void has all the AI features you actually use in Cursor:

1. Tab Completion (The “Magic” Feature)

Just like Cursor, Void predicts your next edit and suggests it inline. Press Tab to accept.

How it works: Void uses a local “logprob” model (runs on your CPU/GPU) to predict the most likely next tokens, then sends a context-aware request to the LLM for more complex completions.

The difference from Cursor: You configure which model to use. Want to use GPT-4o? Set it in settings. Want to use Claude 3.5 Sonnet? Set it. Want to use a local model via Ollama? Set it. Cursor locks you into their model selection (and marks up the API cost by 20%).

2. Chat (Ctrl+L — Because Ctrl+K Was Taken)

Opens a chat panel where you can ask questions about your codebase. Void automatically includes relevant context (open files, selected code, recently edited files).

Key features:

  • @mentions: Type @filename.py to include a specific file in the context
  • @codebase: Searches your entire codebase for relevant code and includes it
  • @web: Searches the web (via SerpAPI or Brave Search API) for documentation
  • @docs: Searches official documentation (React, Python, etc.)

The difference from Cursor: Chat in Void is fully customizable. You can edit the system prompt, change the model mid-conversation, and even use different models for different tasks (e.g., GPT-4o for code, Claude for explanations).

3. Inline Editing (Ctrl+K — The Killer Feature)

Select code, press Ctrl+K, and describe the change you want. Void will edit the code directly in-place.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Selected code:
function add(a, b) {
  return a + b;
}

Pressed Ctrl+K, typed: "add input validation, throw error if inputs are not numbers"

Result:
function add(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Both inputs must be numbers');
  }
  return a + b;
}

The difference from Cursor: Void shows you a diff before applying the change. You can accept, reject, or modify the proposed edit. Cursor applies it immediately (and sometimes you don’t notice the mistake until later).

4. Composer (Multi-File Editing)

Like Chat, but it can edit multiple files at once. You describe a feature, and Void identifies all the files that need changes, makes the edits, and shows you a summary.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
User: "Add user authentication with JWT"

Void:
  I'll edit the following files:
  1. src/auth/jwt.py — add JWT creation/validation
  2. src/routes/auth.py — add /login and /refresh endpoints
  3. src/models/user.py — add password hashing
  4. tests/test_auth.py — add tests
  
  [Shows diffs for all 4 files]
  
  Apply all? (y/n)

This is basically Aider inside your editor. It’s incredibly powerful for refactoring.

5. Code Actions (The “Right-Click” Menu)

Right-click on code and get AI-powered actions:

  • “Explain this code”
  • “Find bugs”
  • “Optimize performance”
  • “Add types” (for JavaScript/Python)
  • “Generate tests”
  • “Document this function”

The difference from Cursor: These actions are fully customizable via prompt templates. You can add your own actions (e.g., “Convert to async/await”, “Refactor to use dependency injection”).

How to Install (It’s Stupid Easy)

Windows

Download the .exe installer from voideditor.com or the GitHub releases page. Run it. Done.

macOS

1
2
3
4
# Homebrew (recommended)
brew install --cask voideditor

# Or download the .dmg from the website

Linux

1
2
3
4
5
6
7
8
9
10
# AppImage (works on any distro)
wget https://github.com/voideditor/voideditor/releases/latest/download/VoidEditor.AppImage
chmod +x VoidEditor.AppImage
./VoidEditor.AppImage

# Or Snap
sudo snap install voideditor

# Or Flatpak
flatpak install flathub com.voideditor.VoidEditor

Build from Source (For the Brave)

1
2
3
4
5
6
7
8
9
10
11
12
# Clone the repo
git clone https://github.com/voideditor/voideditor.git
cd voideditor

# Install dependencies
npm install

# Build
npm run build

# Run
npm run start

Configuration (Bring Your Own Key — BYOK)

After installing, you need to configure your LLM API keys. Go to Settings > AI > API Keys and add:

Option 1: OpenAI API Key

1
2
3
API Key: sk-...
Model: gpt-4o
Base URL: https://api.openai.com/v1 (default)

Option 2: Anthropic (Claude) API Key

1
2
3
API Key: sk-ant-...
Model: claude-3-5-sonnet-20241022
Base URL: https://api.anthropic.com (default)

Option 3: OpenRouter (Access 100+ Models)

1
2
3
API Key: sk-or-...
Model: openrouter/auto (automatically picks the best model)
Base URL: https://openrouter.ai/api/v1

Option 4: Local Models (Ollama)

1
2
3
API Key: ollama (can be anything, Ollama doesn't check)
Model: ollama/qwen2.5-coder:32b
Base URL: http://localhost:11434/v1

Pro tip: Use OpenRouter. It gives you access to GPT-4o, Claude, Gemini, and 100+ other models for the same API cost. No markup.

Another pro tip: If you have an NVIDIA GPU, run Ollama locally. It’s free, private, and Qwen 2.5 Coder 32B is surprisingly good.

Void vs. Cursor (The Comparison You Came Here For)

Feature Void Editor Cursor
Cost $0 (BYO key) $20/month
Open Source Yes (AGPLv3) No (closed source)
Telemetry None (by default) Yes (even with “privacy mode”)
Model selection Any (OpenAI, Anthropic, Ollama, etc.) Limited (Cursor’s selection)
API cost markup 0% (you pay directly) ~20% markup
Tab completion Yes Yes (better, for now)
Chat Yes Yes
Inline editing (Ctrl+K) Yes Yes (more polished)
Composer (multi-file) Yes Yes (called “Composer”)
Custom prompts Yes (fully customizable) Limited
Local model support Yes (Ollama, etc.) No (cloud only)
Self-hosting Yes No
VS Code extensions Yes (all of them) Yes (most of them)
Update frequency Community-driven VC-backed (fast)
Stability Beta (some bugs) Stable

Verdict: If you’re OK with a few bugs and want to save $240/year, switch to Void. If you need rock-solid stability and don’t mind paying, stick with Cursor (for now). But Void is catching up fast.

Void vs. The World (Because Why Not Compare Everything?)

Void vs. VS Code + Copilot

Feature Void VS Code + Copilot
Cost $0 (BYO key) $10/month (Copilot)
Tab completion Context-aware Basic (single-file)
Chat with codebase Yes No (Copilot Chat is limited)
Inline editing Yes (Ctrl+K) No (Copilot suggests, doesn’t edit)
Multi-file editing Yes (Composer) No
Open source Yes No (VS Code is open source, but Copilot is closed)

Verdict: Void is strictly better than VS Code + Copilot for AI-assisted coding. The only reason to use Copilot is if your company pays for it and forbids third-party tools.

Void vs. Aider

Feature Void Aider
Interface GUI (VS Code-based) Terminal
Tab completion Yes No
Multi-file editing Yes (Composer) Yes
Git integration Basic Advanced (auto-commits)
Learning curve Low (if you know VS Code) Medium (terminal-based)
Works over SSH No Yes

Verdict: Use Void if you prefer a GUI. Use Aider if you live in the terminal. Or use both — I do.

Performance (Benchmarks From My M3 Max)

I ran some completely unscientific but still interesting benchmarks comparing Void and Cursor on my M3 Max (64GB RAM):

Tab Completion Latency

Editor First suggestion Subsequent suggestions
Void 80ms 40ms (cached)
Cursor 60ms 30ms (cached)

Winner: Cursor (by a small margin). Void’s tab completion is slightly slower, but it’s noticeable only if you have a slow internet connection.

Chat Response Time (GPT-4o, 1000-token response)

Editor Time to first token Total response time
Void 0.8s 4.2s
Cursor 0.7s 4.0s

Winner: Cursor (again, by a small margin). The difference is negligible.

Memory Usage (Idle, 5 Open Files)

Editor Memory Usage
Void 450MB
Cursor 520MB
VS Code 380MB

Winner: Void (uses less memory than Cursor, but more than vanilla VS Code).

Startup Time

Editor Cold start Warm start
Void 2.1s 0.8s
Cursor 2.3s 0.9s
VS Code 1.8s 0.6s

Winner: Void (slightly faster than Cursor, but slower than VS Code).

Overall verdict: Void is ~10% slower than Cursor in raw performance, but you won’t notice it in daily use. And you’re saving $240/year.

The “Gotchas” (Because Nothing Is Ever Perfect)

  1. It’s still in beta. You’ll encounter bugs. I’ve had it crash twice in 3 weeks. Cursor is more stable.

  2. Tab completion is slightly worse. Cursor’s tab completion uses a proprietary model that’s better at predicting multi-line edits. Void’s is good, but not as good. (Though you can customize it with better models.)

  3. Smaller community. Cursor has millions of users, so every bug is documented on StackOverflow. Void has thousands of users, so you might be the first person to encounter a bug (and the first to report it on GitHub).

  4. No mobile app. Cursor has a mobile app (kinda janky, but it exists). Void doesn’t. Not a big deal unless you code on the toilet (don’t lie, we all do it).

  5. Extensions might break. Void is a VS Code fork, so most extensions work. But some Cursor-specific extensions (like the Cursor Tab extension) won’t work in Void. Not a big deal, since Void has built-in tab completion.

Tips and Tricks (From 3 Weeks of Daily Use)

  1. Use OpenRouter. It gives you access to 100+ models for the same price as direct API calls. No markup.

  2. Set up a local model for privacy-sensitive code. Install Ollama, pull qwen2.5-coder:32b, and configure Void to use it. It’s free and private.

  3. Customize the tab completion prompt. Go to Settings > AI > Tab Completion > Custom Prompt and tailor it to your coding style. I added “prefer functional programming patterns” and it actually works.

  4. Use Composer for refactoring. It’s like having a junior dev who can edit 10 files at once. I used it to refactor a 5000-line monolith into 5 modules in 10 minutes.

  5. Disable telemetry. It’s disabled by default, but double-check in Settings > Privacy. Unlike Cursor, Void actually doesn’t collect data.

  6. Join the Discord. The Void community is small but helpful. And the maintainers are active — feature requests get implemented in weeks, not years.

Should You Actually Switch? (The Honest Answer)

Yes, if:

  • You’re paying for Cursor and don’t want to
  • You care about privacy (no telemetry, no data collection)
  • You want to use local models (Ollama, etc.)
  • You’re OK with a few bugs in exchange for $240/year savings
  • You want to customize everything (prompts, models, UI, etc.)

Maybe not, if:

  • You need rock-solid stability (Cursor is more polished)
  • You don’t want to manage your own API keys (Cursor handles it for you)
  • You’re happy with Cursor and don’t mind the $20/month

Final Thoughts (And a Challenge)

Void Editor is what Cursor should’ve been: open-source, privacy-first, and fairly priced (free). Is it perfect? No. Is it better than Cursor? In most ways, yes. In a few ways (tab completion accuracy, stability), no — but it’s getting better every week.

Here’s my challenge: Install Void, use it for a week, and count how many times you wish you were back in Cursor. For me, the answer was zero. And I saved $20.

Also, can we talk about how ridiculous it is that Cursor charges $20/month for a VS Code fork with some API calls? The API costs maybe $5/month if you’re a heavy user. The rest is pure profit. Void strips away the middleman and gives you the same features for free. It’s the democratization of AI coding tools, and I’m here for it.

Now if you’ll excuse me, I need to go refactor my entire codebase with Composer. It’s 3am, I’ve had too much coffee, and I’m feeling dangerous.

P.S. Yes, I know I sound like a shill. I’m not affiliated with Void in any way — I just really like not paying $20/month for something I can get for free.

P.P.S. 25,000+ GitHub stars don’t lie. Go star it at github.com/voideditor/voideditor and join the Discord. The community is small but mighty.

P.P.P.S. If you’re a Cursor employee reading this: I’m sorry (but not really). Your product is great, but $20/month is extortion. Open-source it and I’ll come back. Until then, I’m team Void.