The gap between hosted models and local ones on a decent GPU has closed enough that coding tasks now finish without opening Claude. Qwen 3, Llama 3.3, and DeepSeek-Coder run responsive on a 16 GB card and handle refactors, tests, and small features. What was missing was tooling: the local models were fine, the apps around them were not. That changed in the last twelve months. These are the seven desktop apps we tested against real repositories, ranked by which ones we still had installed a week later.
What to look for in a local LLM coding app
Not every “local AI” tool is a fit for coding work. A serious pick should cover most of these:
- Runs models on your machine or LAN, never routing prompts to a hosted API by default.
- Understands a project, not just single files: repo-wide context, file references, and diffs.
- Works inside an editor or ships its own, so completions and refactors land where you write.
- Streams tool calls the way agentic tools do (read file, edit file, run command).
- Handles at least 7B and 14B models without falling over on a 16 GB GPU.
- Ships an OpenAI-compatible API so you can point other tools at the same runtime.
Everything below meets four or more. The top picks meet all six.
Quick comparison
| App | Best for | Platforms | Local | Starting price/mo | Rating |
|---|---|---|---|---|---|
| Continue.dev | Editor extension for local models | Win/Mac/Linux | Yes | Free | 4.6 |
| Ollama | Fast local model runtime | Win/Mac/Linux | Yes | Free | 4.7 |
| LM Studio | GUI for browsing and running models | Win/Mac/Linux | Yes | Free | 4.5 |
| Aider | CLI pair programming | Win/Mac/Linux | Yes | Free | 4.5 |
| Cursor | Agentic IDE with local routing | Win/Mac/Linux | Optional | $20 | 4.6 |
| Cline | Autonomous coding agent | VS Code + Ollama | Yes | Free | 4.4 |
| Tabby | Self-hosted Copilot | Win/Mac/Linux | Yes | Free | 4.3 |
The apps
1. Continue.dev, best editor extension for local models
Continue.dev is a VS Code and JetBrains extension that talks to any OpenAI-compatible endpoint. Point it at Ollama or LM Studio running locally and you get chat, edit, and autocomplete inside the editor. The config.json lets you assign different models to different roles: a small fast model for autocomplete, a bigger one for refactors, a specialist for embeddings.
Where it falls short: Autocomplete latency on very small GPUs shows through. The rules-and-context system is powerful but the docs assume you know why you would want a system prompt file per project. No native desktop app; the value is inside your editor.
Pricing:
- Free: extension, unlimited use with your own models
- Paid: none
Platforms: VS Code and JetBrains on Windows, macOS, Linux
Download: Continue.dev extension
Bottom line: Best pick for staying in your editor with a local model doing the heavy lifting.
2. Ollama, best local model runtime
Ollama is the runtime most of the other apps on this list end up talking to. It runs Llama, Qwen, DeepSeek, Mistral, and dozens more with a ollama run <model> command, exposes an OpenAI-compatible API on port 11434, and handles model downloads, quantization variants, and updates. The desktop apps for Windows, macOS, and Linux install a system-tray daemon.
Where it falls short: UI is minimal by design. You need a separate front-end (Continue, LM Studio, Open WebUI) if you want a chat window. Model management is CLI-first and better through scripts.
Pricing:
- Free: full runtime, all models
- Paid: none
Platforms: Windows, macOS, Linux
Download: Ollama for desktop
Bottom line: Best pick as the engine behind every other tool on this list.
3. LM Studio, best GUI for browsing and running models
LM Studio ships everything Ollama has plus a GUI: a Hugging Face-style model browser, a chat window, and controls for GPU offloading, context length, and system prompts. It also exposes an OpenAI-compatible API on 1234 so Continue, Cursor, and Aider can talk to it.
Where it falls short: Larger footprint than Ollama. Model catalog is curated, so cutting-edge releases sometimes take a day to appear. Non-commercial licensing on the free tier is a factor if you are shipping a product.
Pricing:
- Free: personal use, full features
- Paid: LM Studio for Work at custom pricing for commercial use
Platforms: Windows, macOS, Linux
Download: LM Studio for desktop
Bottom line: Best pick if you want a GUI to compare models before committing.
4. Aider, best CLI pair programming
Aider is a terminal app that treats your repo as the shared workspace. You describe a change, Aider figures out which files to touch, edits them, runs the tests you tell it to, and commits with a message. It works against any OpenAI-compatible endpoint, so Ollama or LM Studio drive it locally.
Where it falls short: CLI-only, so no autocomplete inside your editor. Requires a clean git repo for its edit-and-commit loop to be safe. Slower on very large repos where the file-selection heuristic has more to sift through.
Pricing:
- Free: full app, all features
- Paid: none
Platforms: Windows, macOS, Linux (Python package)
Download: Aider on GitHub
Bottom line: Best pick when you would rather describe a change in words than click through UI to make it.
5. Cursor, best agentic IDE with local routing
Cursor is a VS Code fork focused on AI-first workflows. The Agent mode plans, edits, and tests across a repo. You can route Cursor at Ollama or any local endpoint through the “Override OpenAI Base URL” setting, keeping prompts on your machine while still using Cursor’s agentic UI.
Where it falls short: The paid tier is where most Cursor features live; the free tier caps completions and Agent runs. Local model routing is officially “advanced,” which means the setup is documented but not the default.
Pricing:
- Free: 2000 completions/mo, limited Agent
- Paid: Pro at $20/mo for unlimited completions, Business at $40/user/mo
Platforms: Windows, macOS, Linux
Download: Cursor for desktop
Bottom line: Best pick if you want an agentic IDE and are willing to configure it to talk to a local model.
6. Cline, best autonomous coding agent inside VS Code
Cline is a VS Code extension that runs a step-by-step coding agent inside the editor. It reads files, writes edits, runs terminal commands, and reports back, all from a chat panel that shows every action before applying it. Cline works with any OpenAI-compatible endpoint, so Ollama on the same machine keeps the loop entirely local.
Where it falls short: Local models slower than 30 tokens/sec make the step-by-step loop feel sluggish. Approve-every-action mode is the default, which is safer but adds friction. Some tools work better with hosted frontier models than with 14B locals.
Pricing:
- Free: extension, unlimited use with your own models
- Paid: none
Platforms: VS Code on Windows, macOS, Linux
Download: Cline extension
Bottom line: Best pick when you want a real agent loop without giving up control of the API key.
7. Tabby, best self-hosted Copilot
Tabby is a self-hosted alternative to GitHub Copilot. It runs a server that speaks the Copilot protocol, so any editor with Copilot support (VS Code, JetBrains, Neovim) can point at it. The Docker image is the fastest path to a working setup; the desktop app on Windows, macOS, and Linux runs the same server behind a GUI.
Where it falls short: The completion model is fine but not on the level of Copilot’s proprietary models. Team features (analytics, policies) live in the paid tier. RAG over your codebase is available but takes tuning.
Pricing:
- Free: single-user, unlimited completions
- Paid: Team plan at $19/user/mo for analytics and SSO
Platforms: Windows, macOS, Linux (server + editor plugins)
Download: Tabby for desktop
Bottom line: Best pick if you want a drop-in Copilot replacement your team can run on its own hardware.
How to pick the right one
- If you want the simplest starting point: Ollama plus Continue.dev inside VS Code.
- If you want a chat window while you compare models: LM Studio.
- If you would rather describe changes than click through them: Aider.
- If you want the polished agent experience without the hosted-only lock-in: Cursor pointed at a local endpoint, or Cline for a pure-local loop.
- If you need Copilot for a small team on your own hardware: Tabby.
- If you tried a hosted coding tool and it broke your budget: Any of the four free picks. A 4090 pays for itself against a $200/mo enterprise plan in a couple of months.
FAQ
What is the best free local LLM app for coding?
Continue.dev inside your editor, powered by Ollama in the background, is the most productive free stack. Aider is the strongest CLI-first option. Cline is the best free agent loop.
Do these apps really keep my code private?
Yes when configured against a local endpoint. Ollama, LM Studio, and Tabby all run models on your machine or LAN. The wrappers (Continue, Aider, Cline, Cursor) send prompts to whichever URL you set, so pointing them at localhost keeps everything local. Cursor sends prompts to its own servers by default; the local-endpoint override is what changes that.
What GPU do I need to run a coding model locally?
A 16 GB card runs 14B models at usable speeds and 34B models with heavy quantization. A 24 GB card comfortably runs a full 34B model at 4-bit. On CPU-only, 7B models work but slowly enough that the loop feels frustrating for anything beyond autocomplete.
Can I use these apps with GitHub Copilot?
Tabby speaks the Copilot protocol and drops in as a replacement. The others run alongside Copilot rather than replacing it. Continue and Cline both work fine with Copilot enabled in the same editor.
Which local model is best for coding right now?
For general coding, Qwen 3 Coder 30B and DeepSeek-Coder-V2 16B are the strongest picks that fit on a 24 GB card. For a 16 GB card, Qwen 3 Coder 14B and Codestral 22B (Q4) hit the sweet spot. All four run in Ollama and LM Studio out of the box.
