SpaceX just acquired Cursor for $60 billion. Whether you’re concerned about data privacy under new ownership, philosophically opposed to vendor lock-in, or simply want to stop paying $20/month — now is the time to explore open-source alternatives.

Continue.dev is the strongest option available today. It’s fully open source (Apache 2.0), runs in both VS Code and JetBrains, and lets you bring any model — local or cloud. Your code never has to leave your machine.

This guide walks you through a complete migration from Cursor to Continue.dev, step by step.

Why Continue.dev?

Continue.dev checks every box that privacy-conscious developers care about:

• Open source — Apache 2.0 license. You can audit every line of code, fork it, contribute back.
• Free — No subscription, no usage limits (beyond your own API costs or hardware).
• Bring your own model — Use Ollama locally, or connect to OpenAI, Anthropic, Google, Mistral, or any OpenAI-compatible endpoint.
• Zero telemetry — Opt-in analytics only. With local models, absolutely nothing leaves your machine.
• Multi-IDE — Works in VS Code and JetBrains (IntelliJ, PyCharm, WebStorm, etc.). Cursor is VS Code only.
• Full data sovereignty — Your code, your prompts, your completions. All local.

For a deeper comparison, see our Continue.dev vs Cursor vs Copilot breakdown.

What Continue.dev Offers vs Cursor

Here’s the feature mapping:

Feature	Cursor	Continue.dev
Tab autocomplete	Cursor Tab (proprietary)	Tab autocomplete with any model (StarCoder, Codestral, DeepSeek, etc.)
Chat sidebar	Cmd+L → Cursor chat	Cmd+L → Continue chat sidebar
Inline edit	Cmd+K → describe change	Cmd+Shift+E (or highlight + Cmd+L)
Context providers	@file, @docs, @web	@file, @folder, @code, @docs, @web, @terminal, @git
Custom rules	.cursorrules file	Use @file with a rules.md (not identical, but functional)
Agent / Composer	Multi-file autonomous editing	Not available — this is the gap

The missing Composer/agent mode is the most significant trade-off. We’ll cover how to fill that gap later in this guide.

Prerequisites

Before you start:

• VS Code or any JetBrains IDE (IntelliJ, PyCharm, WebStorm, etc.)
• (Optional) Ollama — for running local models with zero cloud dependency. See our Ollama + Continue.dev setup guide.
• (Optional) API key — for cloud models (OpenAI, Anthropic, Google, etc.) if you prefer cloud inference speed.

Step-by-Step Installation

1. Install the Continue Extension

VS Code Marketplace:

Open VS Code → Extensions (Cmd+Shift+X) → search “Continue” → Install the one by Continue.dev.

Or from the terminal:

code --install-extension continue.continue

JetBrains:

Settings → Plugins → Marketplace → search “Continue” → Install.

2. Open the Configuration

After installation, Continue creates a config file at:

~/.continue/config.json

You can also open it from the Continue sidebar → gear icon → “Open config.json”.

3. Configure Your Models

This is where Continue.dev shines — total flexibility. Here are the most common setups:

Local with Ollama (Free, Fully Private)

First, install Ollama and pull your models:

# Install Ollama (macOS)
brew install ollama

# Pull models
ollama pull deepseek-coder-v2
ollama pull starcoder2:3b

Then configure Continue:

{
  "models": [
    {
      "provider": "ollama",
      "model": "deepseek-coder-v2",
      "title": "DeepSeek Local"
    }
  ],
  "tabAutocompleteModel": {
    "provider": "ollama",
    "model": "starcoder2:3b"
  }
}

This gives you chat (DeepSeek) and autocomplete (StarCoder2) — entirely local, entirely free.

Cloud with Anthropic

{
  "models": [
    {
      "provider": "anthropic",
      "model": "claude-sonnet-4-6",
      "title": "Claude Sonnet",
      "apiKey": "sk-ant-..."
    }
  ],
  "tabAutocompleteModel": {
    "provider": "anthropic",
    "model": "claude-haiku-4",
    "apiKey": "sk-ant-..."
  }
}

Cloud with OpenAI

{
  "models": [
    {
      "provider": "openai",
      "model": "gpt-4o",
      "title": "GPT-4o",
      "apiKey": "sk-..."
    }
  ],
  "tabAutocompleteModel": {
    "provider": "openai",
    "model": "gpt-4o-mini",
    "apiKey": "sk-..."
  }
}

Hybrid (Local Autocomplete + Cloud Chat)

This is my recommended setup — fast local autocomplete that costs nothing, with a powerful cloud model for complex chat questions:

{
  "models": [
    {
      "provider": "anthropic",
      "model": "claude-sonnet-4-6",
      "title": "Claude Sonnet",
      "apiKey": "sk-ant-..."
    }
  ],
  "tabAutocompleteModel": {
    "provider": "ollama",
    "model": "starcoder2:3b"
  }
}

Migrating Your Cursor Workflow

Here’s how to translate your muscle memory:

What you did in Cursor	What to do in Continue.dev
Tab to accept autocomplete	Same — Tab accepts Continue’s suggestions
Cmd+L to open chat	Cmd+L opens Continue chat sidebar
Cmd+K for inline edit	Highlight code → Cmd+Shift+E (or Cmd+L with selection)
Type @file in chat	Type @file in Continue chat — same syntax
Use .cursorrules for project context	Create a rules.md and reference with @file in prompts
Cmd+Shift+I for Composer	No equivalent — use Claude Code in terminal
Cursor’s codebase search	@codebase in Continue (simpler, but functional)

Handling .cursorrules

If you relied on .cursorrules for project-specific instructions, create a rules.md (or .continuerules) in your project root with the same content. Then reference it in your prompts:

@file rules.md

Refactor this function to use the patterns described above.

It’s not automatic like .cursorrules, but it works. Check our complete Continue.dev guide for more advanced context configuration.

What You Gain

• $0/month — With local models, there’s no subscription or API cost. Period.
• Full privacy — Your code, prompts, and completions never leave your machine when using Ollama.
• Model flexibility — Swap between Claude, GPT, Gemini, DeepSeek, Llama, or any new model in seconds. No vendor lock-in.
• Open source — Audit the code. Fork it. Contribute features. No black box.
• JetBrains support — If you work in IntelliJ or PyCharm, Continue works there. Cursor doesn’t.
• Independence — No corporate acquisition can take this away from you.

What You Lose

Let’s be honest about the trade-offs:

• Composer/Agent mode — Cursor’s multi-file autonomous editing is genuinely powerful. Continue has nothing equivalent. This is the biggest gap.
• Polished UX — Cursor is a dedicated app with tight integration. Continue requires more manual config and occasional rough edges.
• Codebase indexing — Cursor indexes your entire project for semantic search. Continue’s @codebase works but is simpler and less thorough.
• Inference speed — If you run local models on modest hardware (8GB RAM laptop), expect slower responses than Cursor’s cloud infrastructure.
• One-click setup — Cursor works out of the box. Continue requires you to choose and configure models.

The Hybrid Approach: Best of Both Worlds

Here’s what I actually recommend for developers who relied heavily on Cursor’s Composer:

Continue.dev in VS Code for:

• Tab autocomplete (local, fast, free)
• Chat sidebar for questions and explanations
• Inline edits for single-file changes

Claude Code in terminal for:

• Multi-file agentic editing (the Composer replacement)
• Complex refactoring across your codebase
• Tasks that require autonomy

This combination replicates ~90% of Cursor’s functionality. Continue handles the IDE integration, Claude Code handles the agentic work. Total cost: $0 to $20/month depending on your Claude Code usage.

See our Cursor to Claude Code migration guide for the terminal side of this setup.

FAQs

Is Continue.dev really free? Yes. The extension is free and open source. You only pay if you choose to use cloud API models (OpenAI, Anthropic, etc.). With local models via Ollama, it’s completely free.

Will my code be sent anywhere? Only if you configure a cloud model provider. With Ollama or other local models, everything stays on your machine. Continue has no telemetry by default.

Can I use multiple models? Yes. You can configure multiple models in your config.json and switch between them in the chat sidebar. Many developers use a fast local model for autocomplete and a powerful cloud model for chat.

Does it work with my language/framework? Continue.dev is language-agnostic. It works with anything VS Code or JetBrains supports.

What about Cursor’s .cursorrules — can I keep them? Not natively. But you can use @file to reference a rules document in each prompt. It’s an extra step, but achieves the same result.

How does autocomplete quality compare? It depends entirely on your model choice. With Codestral or DeepSeek Coder V2, autocomplete quality is comparable to Cursor Tab. With smaller local models, there’s a trade-off between speed and quality.

Next Steps

• Complete Continue.dev setup guide — deep dive into all configuration options
• Best Cursor alternatives after SpaceX acquisition — comparison of all options
• Ollama + Continue.dev local setup — fully private AI coding on your machine
• Continue.dev vs Cursor vs Copilot — detailed feature comparison

---

The SpaceX acquisition doesn’t mean Cursor will get worse overnight. But if you value open source, privacy, and independence from corporate decisions — Continue.dev gives you all of that today, with remarkably little compromise. The only real gap is agent mode, and the ecosystem is closing that fast.

Your code. Your models. Your rules.