Open-source alternatives to GitHub Copilot: 3 AI coding assistant tools compared
Replacing a hosted coding assistant means owning the model provider, the context your code is sent to, and the upgrade path, and one of the three candidates here has stopped answering: the Continue repository's own README says it is no longer actively maintained. Cline is the one most readers should look at first, and Tabby is the answer when the model has to run inside your own network.
What GitHub Copilot does, and why people look elsewhere
GitHub Copilot is a hosted AI coding assistant: inline completions, chat and agent modes inside editors, running on models chosen by GitHub.
- code context is sent to the vendor's servers
- per-user subscription
- models and providers cannot be swapped for a local or self-hosted one
The candidates at a glance
| Project | Licence | Maintenance | Language | GitHub stars | Install | Best for |
|---|---|---|---|---|---|---|
| continuedev/continue | Apache-2.0Permissive: commercial use allowed | Commits in the last six monthsLast push October 4, 2026 | TypeScript | 36,112 | See analysis | A team that wants an Apache-2.0 coding agent in VS Code, a JetBrains IDE or a terminal and is willing to own maintenance from here. The final 2.0.0 builds of the extension, the CLI and the plugin are still published, and the licence does not expire. |
| TabbyML/tabby | Custom licenceCustom licence: read the LICENSE file | Commits in the last six monthsLast push June 30, 2026 | Rust | 33,905 | See analysis | Teams that must keep source code on premises and have at least one machine with a consumer-grade GPU. Tabby is self-contained, needs no external database or cloud service, runs the model itself, and publishes an OpenAPI interface for integration with existing infrastructure. |
| cline/cline | Apache-2.0Permissive: commercial use allowed | Commits in the last six monthsLast push October 11, 2026 | TypeScript | 70,170 | See analysis | A team that wants an agent rather than a completion engine. Cline shows every edit as a reviewable diff with checkpoints, runs commands in the terminal, and works with Anthropic, OpenAI, Google, Bedrock, Vertex, Ollama, LM Studio or any OpenAI-compatible endpoint. |
Each alternative in detail
continuedev/continueopen-source coding agent
- Best for
- A team that wants an Apache-2.0 coding agent in VS Code, a JetBrains IDE or a terminal and is willing to own maintenance from here. The final 2.0.0 builds of the extension, the CLI and the plugin are still published, and the licence does not expire.
- What you give up
- Its own README states the repository is no longer actively maintained and read-only for all users, and our analysis of Continue records the last push as 2026-06-19 with no further commits expected, so there is no upstream fix path, no new model support and no security response channel. That analysis also tells you to check that the VS Code Marketplace listing or the @continuedev/cli package still resolves, and that your model provider is one the 2.0.0 configuration supports. The README recommends the CLI over the JetBrains plugin.
TabbyML/tabbySelf-hosted AI coding assistant
- Best for
- Teams that must keep source code on premises and have at least one machine with a consumer-grade GPU. Tabby is self-contained, needs no external database or cloud service, runs the model itself, and publishes an OpenAPI interface for integration with existing infrastructure.
- What you give up
- The licence field is a custom licence GitHub cannot classify, and our analysis of Tabby says the repository carries a NOASSERTION SPDX identifier that needs independent legal review before you build on it. You also need a GPU that the model registry at tabby.tabbyml.com/docs/models/ lists as supported, which rules it out for a laptop-only team. Our analysis records no install command for it, and the last push is 2026-06-30 with v0.32.0 from 2026-01-25 the most recent tagged release in its list.
cline/clineAutonomous coding agent as an SDK, IDE extension, or CLI assistant.
- Best for
- A team that wants an agent rather than a completion engine. Cline shows every edit as a reviewable diff with checkpoints, runs commands in the terminal, and works with Anthropic, OpenAI, Google, Bedrock, Vertex, Ollama, LM Studio or any OpenAI-compatible endpoint.
- What you give up
- The repository states that it is not open-sourcing the JetBrains plugin, so that part of the stack sits outside the Apache-2.0 project, while the SDK, CLI, VS Code extension and Kanban board are inside it. Our analysis of Cline tells you to skip it if you need a hosted service with a support contract, or an agent that runs unattended against a production branch on day one, and to confirm that a test edit is recoverable through the checkpoint history before rolling out.
Two live options and one frozen codebase
GitHub Copilot is a hosted coding assistant: inline completions, chat and agent modes inside your editor, running on models GitHub chooses. Three documented things make people look elsewhere. Code context is sent to the vendor's servers. The subscription is per user. And the models and providers cannot be swapped for a local or self-hosted one. Each of the three tools here answers part of that, and one of them has stopped answering.
The difference in approach is large. Continue is a coding agent shipped as a VS Code extension, a CLI and a JetBrains plugin, with configuration documented on its own site. Its README carries a notice that the repository is no longer actively maintained and is read-only for all users, and our analysis of Continue records the last push as 2026-06-19 with no further commits expected. The 2.0.0 release was the final one, described in the README as removing anonymous telemetry, pulling out authentication and squashing bugs, and the same page recommends the CLI over the JetBrains plugin. Nothing about the licence expires, so the builds keep resolving; what stops is the roadmap.
Tabby is a server. Its README describes a self-hosted assistant that needs no DBMS and no cloud service, supports consumer-grade GPUs, and exposes an OpenAPI interface, alongside an editor extension and an internal knowledge engine it calls the Answer Engine. Cline is an agent rather than a server too, but a different one: it runs commands in your terminal, watches compiler and linter output, and works in Plan and Act modes where every file edit and terminal command needs your approval unless you turn approval off.
Scope is worth stating. This page covers three tools that run on your own machine or your own network. It does not cover a hosted assistant you can only subscribe to, and it does not cover a code search tool that only indexes and answers questions, because neither changes who sees your code.
Completion versus agent: the axis that decides it
Underneath the feature lists, these three make different bets about what an assistant is for.
Tabby and Continue sit closest to the completion model people already know: a suggestion as you type, plus a chat surface. Tabby adds a knowledge engine over internal documents, and its release history includes an @ menu for pulling files into the chat as context, a code browser and repository context in completions. Continue's final release stripped out the parts of the product that did not fit that shape.
Cline assumes it will change files and run commands. Its README describes coordinated changes across a codebase, monitoring linter and compiler errors and fixing missing imports or type mismatches as it works, with every edit shown as a diff you can review, modify or revert, and all changes tracked with checkpoints. For long-running processes it keeps working in the background and reacts to new output as it appears.
That difference moves the risk profile more than any feature list does. A completion tool is occasionally wrong and costs a keystroke. An agent that runs shell commands and can commit to a branch can be wrong at real cost, which is why Cline ships Plan and Act modes and checkpoint history, and why our analysis of Cline tells you to keep a human in the loop or write .clinerules files that constrain what the agent may touch.
Solo, small team, compliance, embedding
Solo. A single developer who wants their own model and no server to maintain gets the shortest path from Cline's provider list, which includes Ollama and LM Studio, or from Tabby if there is a spare GPU. Continue's CLI is still a published package under Apache-2.0, but adopting it means adopting a codebase nobody is committing to.
Small team. Cline is the practical pick, and the reason is its shape rather than its model list. The CLI has a headless mode for CI and scripting, the Kanban board runs agents in parallel from a web task board where each card gets its own worktree, auto-commit and dependency chains, and the SDK exposes the same engine programmatically. A team that wants to build its own review tooling is not blocked.
Company with compliance needs. The question is which code leaves the building. Tabby is the clearest answer, because the model runs on your hardware and the README describes it as self-contained with no cloud service, so a completion request does not have to leave the site. Against that, its licence carries a NOASSERTION identifier, which our analysis of Tabby says requires independent legal review. Cline is Apache-2.0 and can point at a local model, which covers the same ground, at the cost of an agent that is also allowed to run commands.
Developer embedding it. Three paths. Continue ships a CLI, which is a reasonable automation surface, though the analysis warns that nobody upstream is fixing it. Cline ships a Node SDK that its README describes as a programmatic agent API and extension exports, with custom tools, multi-agent teams, connectors and scheduled automations, plus extension through plugins and MCP servers. Tabby's route is different again: an OpenAPI interface, which our analysis describes as intended for integrating with existing infrastructure such as a cloud IDE.
What self-hosting each one costs
The install commands show who is running what.
Cline: a package on npm, with the SDK and the Kanban board published as their own packages. There is no server to operate. What you take on instead is the agent's permissions, because the CLI can run headless in CI, and that analysis tells you to verify that your model provider is reachable from the machine running the agent, that cline mcp can list your MCP servers, and that a test edit is recoverable through the checkpoint history.
Continue: also a package, also no server, which is exactly why the frozen status is the whole story. The last release is the one you deploy, and the analysis asks you to confirm your provider is one the 2.0.0 configuration supports.
Tabby: the heavy one. Our analysis records no install command for it, so the setup path comes from its own documentation. What you commit to is a GPU, and the constraint is concrete: the model registry at tabby.tabbyml.com/docs/models/ is where you check your card is supported, and the README's promise is that no DBMS is needed, so the operational surface is the model and the service around it. The release list also runs parallel channels, with v0.32.0 on 2026-01-25 and a next-alpha tag on 2026-02-09, so which one you follow is a decision you make on purpose. The last push is 2026-06-30.
Licences, and the components you do not get
Two of the three are plainly permissive. Continue and Cline are Apache-2.0, which means a modified deployment, internal or hosted, carries no obligation to publish your changes. Continue's README states Apache 2.0 with a copyright line running to 2026.
Tabby is the one to read carefully. Its licence field is a custom licence GitHub cannot classify, and our analysis of Tabby records a NOASSERTION SPDX identifier, which is the SPDX way of saying the licence text has not been machine-identified and needs a person to read it. That is fine for an internal deployment and a question to settle before you redistribute.
Component boundaries are the other trap. Cline's index states plainly that it is not open-sourcing JetBrains plugins, so the IntelliJ client sits outside the Apache-2.0 project, and its VS Code extension row is marked as work in progress while migrating. Continue's README recommends the CLI over its JetBrains plugin, which is a gentler version of the same boundary.
None of the three ships a model. That is the line running through all of them: the assistant is the harness, and the weights and the inference come from somewhere you choose.
Bottom line
A team that wants an assistant it can shape around its own workflow should start with Cline, because it is Apache-2.0, model-agnostic down to a local Ollama or any OpenAI-compatible endpoint, and its checkpoints and .clinerules files are the mechanism for keeping an autonomous agent inside a boundary. A team whose requirement is that code never leaves the network should look at Tabby, confirm the GPU is in the model registry, and have someone qualified read the licence file. Continue belongs in a different column: the builds work and the Apache-2.0 grant does not expire, but the README says the repository is read-only, so treat it as a codebase you are adopting rather than a project you are joining. Before committing, verify that a test edit is recoverable, that your provider is reachable from the machine that runs the agent, and who answers when the extension breaks.