</>macrostackBrowse all
Migration guide · AI Coding Assistants

The 5 best Cursor alternatives

Cursor is an AI-first code editor from Anysphere, Inc. It gives you a familiar VS Code-style workspace with an autonomous Agent, inline Tab completion and codebase-wide context, and it imports your existing VS Code settings, extensions and keybindings in one click. Third-party extensions come from the Open VSX registry rather than Microsoft's marketplace, and Anysphere publishes first-party replacements for a few widely used extensions Open VSX doesn't carry. It is a genuinely polished product — for a lot of developers it was the first tool that made agentic coding feel native rather than bolted on, and its Tab completion is still the benchmark others are measured against.

92
Bottom line

For most people coming from Cursor the honest swap is Cline — an Apache-2.0 agent that installs into the VS Code or JetBrains you already have, runs on your own API key or a local model, and puts no vendor backend in the request path. Prefer a terminal? opencode is the MIT one with the largest community. Need it sandboxed on your own server? OpenHands. Want the cheapest polished option and don't need openness? GitHub Copilot Pro is $10/month. Note that the pick is not simply the highest Sovereignty Score — opencode scores higher — because the score measures openness, and Cline wins on being the smallest change for someone coming from a VS Code-shaped editor.

Jump to the full comparison →

The cost

Verified on cursor.com 2026-07-29. Hobby is free with limited Agent requests. Pro is $20/month and includes $20 of third-party model usage; Pro+ is $60/month with $70 included; Ultra is $200/month with $400 included. Teams runs $40/user/month for a Standard seat and $120/user/month for Premium; Enterprise is custom. Usage past the included allowance is billed at standard API rates, so the real monthly figure tracks how hard you drive the agent — the seat price is a floor, not a ceiling.

Why people consider an alternative

Three practical reasons come up most. Cost predictability: heavy agent use burns through the included model allowance and spills into usage billing, and the ladder from $20 to $60 to $200 is a steep one for an individual. Architecture: Cursor's own data-use page is explicit that even on your own API key, "your requests will still go through our backend" — so you cannot point Cursor at a model running on your own machine and keep the whole loop in-house, which rules it out for some regulated, air-gapped or client-confidential work. And vendor continuity: on 16 June 2026 SpaceX announced it will acquire Anysphere for $60 billion, with the deal expected to close in the third quarter of 2026. A change of ownership at that scale is something many procurement and security teams re-run a tool evaluation over, independent of how it turns out.

When Cursor is still the right call

Genuinely: if the agent is earning its keep, Cursor is one of the most polished implementations of this idea available, and every alternative here asks you to assemble more of it yourself. Stay if Tab completion is core to how you work — none of the open agents below ship inline autocomplete, and that is the single biggest capability gap. Stay if you would rather pay one vendor than maintain a client plus a provider account plus your own billing. Stay if your team is already on Teams seats with SSO, admin-enforced Privacy Mode and usage analytics, because rebuilding that governance yourself is real work. And stay if you simply don't want to think about model routing — the included allowance handles it. At $20/month, Pro is also not expensive against an hour of developer time; the cost objection bites mainly at Pro+, Ultra, or across a lot of seats. A pending change of ownership is a reason to re-evaluate on your normal cycle, not a reason to move today.

AlternativeLicenseSelf-hostPricingSovereignty
ClineApache-2.0YesFree and open source (Apache-2.0) — you pay only your model provider. Optional prepaid Cline credits and a paid enterprise tier exist; bring-your-own-key needs no account.92
opencodeMITYesFree and open source (MIT) — you pay your own provider. The optional opencode Zen gateway is pay-as-you-go, with some free models; your own API keys cost nothing extra.93
OpenHandsMITYesFree and open source (MIT) to self-host — you pay only your model provider. Managed OpenHands Cloud and a licensed enterprise self-host are the paid tiers.91
AiderApache-2.0YesFree and open source (Apache-2.0) — you pay only your model provider. No account, no hosted tier, no credits.89
GitHub CopilotProprietary (hosted service; MIT-licensed VS Code chat client)NoFree tier (2,000 completions/month); Pro $10/mo; Pro+ $39/mo; Max $100/mo; Business $19/seat/mo; Enterprise $39/seat/mo. Verified on GitHub's own plans documentation 2026-07-29.28
92
Macrostack's top pick

Cline

The open-source agent that lives in the editor you already have.

Which one fits your situation?

There is no single best answer — it depends on what you are actually trying to do.

Just tell me the best Cursor alternative

Cline92

Our top pick — the highest Sovereignty Score at 92, and the one we would choose ourselves.

Cline vs opencode

I have no budget — is there a genuinely free one?

opencode93

Open source under MIT. Free and open source (MIT) — you pay your own provider. The optional opencode Zen gateway is pay-as-you-go, with some free models; your own API keys cost nothing extra.

opencode vs Cline

I want to self-host it and own the data

OpenHands91

Self-hostable, so your data stays on your own server. Free and open source (MIT) to self-host — you pay only your model provider. Managed OpenHands Cloud and a licensed enterprise self-host are the paid tiers.

OpenHands vs Cline

It is just me — I do not want to run a server

Aider89

Offers a hosted option, so you can start without infrastructure. Free and open source (Apache-2.0) — you pay only your model provider. No account, no hosted tier, no credits.

Aider vs Cline

Every alternative, compared

#1★ TOP PICK

Cline

The open-source agent that lives in the editor you already have.

92
OPEN SOURCEApache-2.0SELF-HOSTLOCAL-FIRST

Cline (Apache-2.0, by Cline Bot Inc.) is an autonomous coding agent that installs as a VS Code extension, a JetBrains plugin or a CLI — so you keep your editor, your extensions and your keybindings and simply add the agent. It is model-agnostic: bring your own key for Anthropic, OpenAI, Google, Bedrock and 100+ others, or point it at Ollama or LM Studio and run the whole loop on your own machine. Cline sells optional prepaid credits and an enterprise tier, but nothing about the extension requires an account, and with your own key there is no Cline backend in the request path. At roughly 4.81 million VS Code installs and 65.2k GitHub stars it is the most widely adopted open-source coding agent, and because it is published on Open VSX you can also install it inside Cursor itself.

Cline itself runs on anything that runs VS Code — the hardware question is only about the model. Cline's own docs put local models at 16–32 GB RAM for small quantised models, 32–64 GB for mid-size coding models and 64 GB+ for larger ones with expanded context. As a concrete anchor, Ollama's default qwen3-coder tag (30B total, ~3.3B active) is a 19 GB download with a 256K context window, so roughly 24 GB of VRAM — or a 32 GB+ unified-memory machine — is a sensible floor for comfortable agentic work. Below that, a cloud API key is usually the better call, and a local model still won't match a frontier cloud model on hard multi-file tasks.

Strengths

  • +Keeps your existing IDE, extensions and keybindings — the smallest possible change from Cursor
  • +Bring-your-own-key with no account required: 100+ providers, or fully local via Ollama / LM Studio
  • +Plan/Act split and diffs you approve before anything is written, plus MCP tool support
  • +The most-adopted open agent in the category: ~4.81M VS Code installs, 65.2k stars, commits daily

Trade-offs

  • No inline Tab-style autocomplete — Cline is an agent, not a completion engine, and this is its most-requested missing feature
  • You manage your own API billing; long agent runs on a frontier model can cost more than a $20 Cursor seat
  • Cline's own prepaid-credits path is the promoted onboarding — bring-your-own-key takes a couple of extra settings
  • Running a capable model locally is a real hardware ask (see the hardware note)
Free and open source (Apache-2.0) — you pay only your model provider. Optional prepaid Cline credits and a paid enterprise tier exist; bring-your-own-key needs no account.
#2

opencode

The terminal-native agent with the largest open-source community in the category.

93
OPEN SOURCEMITSELF-HOSTLOCAL-FIRST

opencode (MIT) is a coding agent that runs in your terminal, with a desktop app in beta and IDE extensions alongside it. It is deliberately provider-agnostic — 75+ providers via the AI SDK and Models.dev, including Ollama, LM Studio and any OpenAI-compatible local endpoint — and it ships two built-in agents: a full-access `build` agent and a read-only `plan` agent for exploring a codebase before anything is allowed to change it. It is now the most-starred project in this space at roughly 191k GitHub stars, maintained by Anomaly after the repository moved from `sst/opencode` to `anomalyco/opencode`. The optional opencode Zen gateway sells curated, benchmarked models pay-as-you-go and includes some free ones; using your own provider keys stays free.

The client is a single binary and runs comfortably on modest hardware, including over SSH. Running the model locally is the demanding part: budget ~24 GB VRAM or a 32 GB+ unified-memory machine for a 30B-class quantised coding model, and expect a capability gap against a frontier cloud model on multi-step agent work.

Strengths

  • +MIT and provider-agnostic by design — 75+ providers, plus Ollama, LM Studio or any OpenAI-compatible local endpoint
  • +The read-only `plan` agent lets you scope work before the agent can touch a file
  • +Terminal-first, so it works over SSH on a server or a modest machine
  • +The largest community in the category and daily commits

Trade-offs

  • Terminal-first is a genuine adjustment coming from an editor-integrated agent; the desktop app is still beta
  • No inline autocomplete — a different tool for a different job than Cursor's Tab
  • Ownership moved from SST to Anomaly; the MIT licence means no practical risk, but it's worth knowing
  • Large configuration surface (providers, models, agents) — more to learn than picking from a dropdown
Free and open source (MIT) — you pay your own provider. The optional opencode Zen gateway is pay-as-you-go, with some free models; your own API keys cost nothing extra.
#3

OpenHands

Self-hosted, sandboxed coding agents — the whole stack runs on infrastructure you control.

91
OPEN SOURCEMITSELF-HOSTLOCAL-FIRST

OpenHands (MIT, formerly OpenDevin) is the option for people whose actual requirement is "this has to run on infrastructure I control." It is a self-hosted control centre for coding agents: a browser-based Agent Canvas plus a backend server you start locally or on your own VM, with agents working inside a sandboxed environment that has its own shell, filesystem and browser. Agents can edit code, run commands, call APIs and browse the web — real engineering tasks rather than completions. The project sells a managed OpenHands Cloud and licenses a self-hosted enterprise edition, but the core is MIT and self-hosting costs nothing beyond your own model usage. At 82.5k stars it is the most established self-hosted agent platform available.

Plan for a machine that can comfortably run Docker plus a sandbox container alongside your normal workload — 16 GB RAM is a practical minimum and 32 GB is more comfortable, whether that's a workstation or a small VM. If you also want the model in-house, that is a separate ~24 GB VRAM budget on top.

Strengths

  • +Genuinely self-hosted: server, sandbox and workspace all sit on your own infrastructure
  • +Sandboxed execution — the agent gets a container, not unrestricted access to your laptop
  • +Browser UI suits longer autonomous runs and reviewing what an agent actually did
  • +MIT-licensed, 82.5k stars, committed to daily

Trade-offs

  • The heaviest setup here — Docker and real RAM, not a two-minute install
  • Long autonomous runs consume a lot of tokens; set a budget before you let one loose
  • Multi-user, RBAC and the richer integrations live in the paid Cloud and enterprise tiers
  • Not an in-editor experience — you leave your IDE to drive it, and there's no inline completion
Free and open source (MIT) to self-host — you pay only your model provider. Managed OpenHands Cloud and a licensed enterprise self-host are the paid tiers.
#4

Aider

Git-native pair programming in the terminal — every change lands as a commit.

89
OPEN SOURCEApache-2.0SELF-HOSTLOCAL-FIRST

Aider (Apache-2.0) is the minimalist of this group: a Python CLI that edits files in your repository and commits each change with a sensible message, so your review tool is `git diff` and your undo is `git revert`. It connects to almost any LLM including local ones — `aider --model ollama_chat/<model>` with `OLLAMA_API_BASE` set — and it has no account, no backend and no vendor anywhere in the path. The honest caveat is cadence: the most recent PyPI release (0.86.2) landed on 12 February 2026 and the latest commit on GitHub is 22 May 2026. It still works, and 47.8k people star it, but in a field where models change monthly that is a noticeably slower pulse than the others here — which is why it scores well on sovereignty and lower on maintenance.

The lightest option here: a Python CLI that will happily run on a low-powered machine or a small VM while calling a cloud model. If you want the model local too, the same ~24 GB VRAM guidance applies for a 30B-class quantised coding model, and Aider's Ollama docs are worth reading first because of the default context-window behaviour.

Strengths

  • +Git-native: every edit is a commit you can diff, revert or cherry-pick — the best audit trail of the group
  • +No account, no backend, no vendor in the request path at all
  • +The lightest client here — a Python CLI that runs anywhere, including over SSH on modest hardware
  • +Clear, well-documented local-model path via Ollama

Trade-offs

  • Development has slowed sharply — last PyPI release 12 February 2026, last commit 22 May 2026
  • Terminal only: no editor UI and no inline completion
  • Ollama defaults to a 2k context window and silently discards overflow, so local setups need deliberate configuration (Aider's docs cover it, but it is a footgun)
  • A leaner feature set than the newer agents — no sandboxing or built-in browser tooling
Free and open source (Apache-2.0) — you pay only your model provider. No account, no hosted tier, no credits.
#5

GitHub Copilot

The polished commercial option at half the price — and for many readers the honest answer.

28
SOURCE-AVAILABLEProprietary (hosted service; MIT-licensed VS Code chat client)

If what actually prompted the comparison is price rather than openness, GitHub Copilot is the straightforward answer: Pro is $10/month against Cursor Pro's $20, and there is a real free tier with 2,000 code completions a month for individual developers who don't have Copilot through an organisation. It does inline completion, chat, agent mode and a CLI, and it installs into the IDE you already use rather than asking you to adopt a different editor. Worth knowing precisely: the Copilot Chat client for VS Code is MIT-licensed and its code now lives in the main VS Code repository, but the service and models behind it are proprietary and hosted. There is no self-host path and no local-model option — that's the trade, stated plainly, and it is the right trade for plenty of people.

Strengths

  • +Half the price of a Cursor Pro seat, with a genuinely free tier to test on
  • +Nothing to run or configure — it installs into the IDE you already use
  • +Keeps inline Tab-style completion, which none of the open agents above provide
  • +Very low switching cost — your code is just files, so uninstalling leaves nothing to migrate

Trade-offs

  • Fully hosted and proprietary: no self-hosting, no local models, no offline use
  • Chat, agent and CLI usage draws on monthly credits; only completions are unlimited on paid plans
  • You are choosing a Microsoft/GitHub-operated service, with whatever that means for your data policy
  • The Sovereignty Score of 28 reflects a closed hosted service — a transparency lens, not a verdict on quality
Free tier (2,000 completions/month); Pro $10/mo; Pro+ $39/mo; Max $100/mo; Business $19/seat/mo; Enterprise $39/seat/mo. Verified on GitHub's own plans documentation 2026-07-29.

Questions people ask

What happened to Continue, Roo Code and Void? They used to be the standard answers.

They were, and all three changed status in 2026 — which is exactly why we re-check rather than repeat an old list. Roo Code’s extension was shut down on 15 May 2026 and its repository is archived. Void was deprecated and its repository archived on 2 June 2026. Continue is a different case: the repository is still open and still receives commits, but its last feature release was v2.1.0 on 19 June 2026 and everything since has been documentation changes — including one retiring the hosted login flow. The Apache-2.0 extension still works against your own API keys; what has stopped is new model support and active development. If you are already on Continue there is no emergency, but we would not start there in 2026.

Can I keep Cursor and just add an open-source agent to it?

Yes, and it's a sensible way to test one without changing editors. Cursor draws third-party extensions from the Open VSX registry, and Cline is published there under Apache-2.0 (v4.0.12 as of 28 July 2026, ~5.5M Open VSX downloads), so it installs into Cursor and runs on your own API key. Be precise about what that buys you, though: Cline's requests go straight to your chosen provider, but Cursor's own built-in features still route through Anysphere's backend. Running Cline inside Cursor lowers your model bill and gives you an exit path — it does not make the setup local.

Do any of these genuinely run offline on my own hardware?

Technically yes — Cline, opencode and Aider all support Ollama, LM Studio or any OpenAI-compatible local endpoint, and OpenHands runs its entire stack on your own infrastructure. The honest part is capability and cost. Cline's docs suggest 16–32 GB RAM for small quantised models, 32–64 GB for mid-size coding models and 64 GB+ for larger long-context ones; Ollama's default qwen3-coder tag (30B total, ~3.3B active) is a 19 GB download with a 256K context window, so ~24 GB VRAM or a 32 GB+ unified-memory machine is a realistic floor. And a local model in 2026 will not match a frontier cloud model on hard multi-file agent work. Fully local is the right answer when the code cannot leave the building; otherwise most people use a cloud key and keep the local path for sensitive repositories.

Is Cursor's Privacy Mode enough if my concern is code confidentiality?

For a lot of teams, yes. Cursor states that with Privacy Mode enabled none of your code is stored by Cursor or any third party, and that it maintains zero-data-retention agreements with its model providers; team and enterprise admins can enforce it, and new members inherit the team setting. Two things to weigh. With Privacy Mode off, Cursor says it may use and store codebase data, prompts, editor actions and code snippets to improve its models — so it matters that it's actually enabled. And codebase indexing uploads chunks of code to compute embeddings, with the embeddings and metadata such as file names and hashes potentially retained. If your requirement is stricter — no code leaves our network, at all — that is an architectural requirement no hosted product satisfies, and it points to a self-hosted agent against a local model.

I just want to spend less. What should I try first?

Two honest routes. If you want it open: install Cline into the editor you already use and add an API key. Developers on moderate use often land under a $20 seat, because you pay per token rather than a subscription plus overage. If openness isn't the point: GitHub Copilot Pro is $10/month flat and there's a free tier to test on. The route that reliably costs more, not less, is a frontier model on your own key driving long autonomous agent runs — that can exceed any subscription quickly. Measure a real week of your own usage before you commit either way.

Why isn't the recommended pick the one with the highest Sovereignty Score?

Because the score measures openness and control, not fit. opencode scores 93 to Cline's 92 — it's MIT and terminal-first — and OpenHands is the most genuinely self-hosted of the group. Cline is the recommendation because for someone coming from Cursor it is the smallest change that keeps the same shape of work: same editor, same keybindings, agent in the sidebar, your own key. If you already live in a terminal, start with opencode instead. The score is a transparency lens you can weigh yourself; the recommendation is editorial judgment, and we show both so you can disagree with us.

What about Gemini CLI, Qwen Code, goose and Kilo Code?

All real, all open source, all actively developed, and all worth a look — we ranked the five above on breadth of fit for someone coming from Cursor, not because these are weaker projects. Gemini CLI (Apache-2.0, ~106k stars) is the strongest free-tier route if you're comfortable in Google's ecosystem. Qwen Code (Apache-2.0, ~26k stars) is a terminal agent built around the open-weight Qwen models, which makes it a natural fit if you intend to host the model yourself too. goose (Apache-2.0, ~52k stars) is an extensible general-purpose agent that goes beyond code. Kilo Code (MIT, ~27k stars) is another actively developed VS Code agent. Star counts verified via the GitHub API on 2026-07-29.

Compare them head-to-head

Related comparisons

Entry last verified 2026-07-29. Licenses and pricing change — spotted something out of date? That's a correction we want.

The Macrostack brief

New swaps, worth your inbox.

A short, occasional email when we add a high-intent alternative or ship a new head-to-head. No spam, no selling your address — unsubscribe in one click.