Read the article for free here.
Open-source coding models caught the frontier in 2026. DeepSeek V4 Pro recently hit a reported 80.6% on the SWE-bench Verified benchmark, sitting right next to the most expensive closed source models in the world.
But here is the catch. The single best open coding model right now needs a server rack you do not have. The one that runs on a single 24GB graphics card is a different model entirely, and it is closer to the top than it has any right to be. The question is not which model is best overall. The question is which model is best that you can run for the kind of coding you actually do.
Here are the 10 worth knowing. One will fit your machine. A different one will fit your wallet.
Tier 1: The Frontier Open Six
These are the models that trade blows with the closed frontier. They range from 400 billion to nearly three trillion parameters. You will likely call these through an API instead of running them on your own hardware. A price war among AI labs means you can rent these models for a fraction of what closed-frontier APIs cost. In this tier, open source means you get a cheap, swappable API endpoint without vendor lock-in.
GLM-5.2
Zhipu built GLM-5.2 for long, multi-step engineering tasks across large repositories. It maintains focus and tracks the variable dependencies across its 1M token context window.
It operates under an MIT license with roughly 753B total parameters. It uses a mixture of experts (MoE) architecture, meaning only a slice of the parameters run per token, in this case, about 40B. It tops the open field on the harder SWE-bench Pro benchmark with a reported 62.1 percent score. The API costs roughly $1.40 for input and $4.40 for output per million tokens.
Handling a 1M token context window requires specific architectural tradeoffs. As context length grows, the attention mechanism usually suffers from the "needle in a haystack" degradation, where facts buried in the middle of the prompt are ignored. GLM-5.2 utilizes a modified rotary position embedding (RoPE) scaling technique that preserves middle-context recall better than its predecessors. When you paste an entire repository's abstract syntax tree into the prompt, the model actually uses it.
Kimi K2.7 Code
Moonshot AI designed Kimi K2.7 Code to act autonomously. You point this model at a GitHub issue describing a race condition in a background worker. It writes the fix, runs your test suite, reads the failure logs, and rewrites the function until the tests pass. The model card indicates the architecture utilizes hundreds of sub-agents to coordinate thousands of steps during a single complex request.
Kimi K2.7 Code has roughly one trillion total parameters and activates 32B per token. It operates under a modified MIT license. If you are building an internal coding agent that needs to iteratively interact with a compiler or a linter, this model provides the necessary tool-use reliability.
The agentic reliability comes from how the model was post-trained. Instead of standard instruction tuning, Kimi K2.7 underwent extensive reinforcement learning on trajectories of successful and failed compiler outputs. It understands that a syntax error is not a failure state, but a signal to adjust the previous output.
DeepSeek V4 Pro and Flash
DeepSeek V4 makes the API route cheaper than paying for the electricity to run your own server. You can process millions of tokens of logs, documentation, and code for pennies, making it the default choice for bulk documentation generation and CI/CD pipeline analysis.
Both the Pro and Flash variants offer a 1M token context window under an MIT license. V4 Pro costs roughly $0.435 for input and $0.87 for output per million tokens. The V4 Flash variant drops that to $0.14 and $0.28.
Integrating this into an automated workflow requires standard OpenAI SDK boilerplate, swapping the base URL and the model ID.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com/v1"
)
# Using the ultra-cheap Flash variant for high-volume log analysis
response = client.chat.completions.create(
model="deepseek-v4-flash",
messages=[
{"role": "system", "content": "You are a strict code reviewer."},
{"role": "user", "content": "Review this pull request for race conditions: ..."}
],
max_tokens=2048
)
print(response.choices[0].message.content)
Qwen3-Coder-480B-A35B
Alibaba released this 480B mixture of experts model under the Apache 2.0 license. It handles 256,000 tokens and scores a reported 69.6 percent on SWE-bench Verified.
Many open-weights models use custom licenses that restrict commercial use or require reporting above certain revenue thresholds. The Apache 2.0 license removes that friction. A company can ship this commercially without a legal review. If you are building a commercial coding product and need a frontier-grade backend that you can legally self-host in a secure enterprise environment, Qwen3-Coder-480B is the safest choice for you.
Deploying a 480B model requires significant infrastructure though. Even at 8-bit quantization, you need nearly half a terabyte of VRAM, meaning an 8x H100 or 8x MI300X node. The 35 billion active parameters per token keep the generation latency low, but the memory capacity required to hold the weights dictates the hardware footprint.
MiniMax M3
MiniMax M3 targets heavy front-end development workflows that require visual context. You can drop a Figma export, a CSS module, and a screenshot of a UI bug into the prompt, asking it to wire up the flexbox layout to match the visual reference. The native multimodal feature maps visual layouts directly to the React components that need fixing.
It features a 1M token context window and scores a reported 59% on SWE-bench Pro. It operates under a custom, commercial-use-restricted license. At roughly $0.30 for input per million tokens, with output pricing varying based on the API provider routing, often landing between $0.96 and $2.40, it is an economical choice for multimodal tasks.
Kimi K3
Moonshot's Kimi K3 dropped its open weights on July 26, 2026, pushing the scale to 2.8 trillion parameters. It features a 1M token context window.
This model is the capability capstone of the current open ecosystem. It handles complex algorithmic reasoning tasks, systems programming, and compiler optimization. Because of its 2.8T scale, it is the hardest of all to self-host and remains effectively API-only for most developers.
Tier 2: The Four You Can Run
Those 6 you rent. These 4 you own.
This is where open source pays off for individual developers. You have no API bill. No proprietary code leaves your machine. The runnable tier is close enough to the frontier that for most day-to-day coding, you will not feel the gap.
Qwen3-Coder-Next
If you own a 64GB or 96GB Mac Studio, or the new 128GB AMD Strix Halo, Qwen3-Coder-Next is your target. It is an 80B total parameter model that scores a reported 70.6 percent on SWE-bench Verified under an Apache 2.0 license.
Because of 4-bit quantization, it runs on roughly 46GB of unified memory. The real engineering trick here is the mixture of experts architecture. Only 3 billion parameters activate per token. This means an 80B-quality coder runs fast on a good desktop, giving you near-frontier reasoning speed without saturating your memory bandwidth.
Memory bandwidth is the silent killer of local LLM performance. When a model generates a token, it must read the active weights from memory into the compute cores. A dense 80B model requires moving 80 billion parameters for every single word it types. By only activating 3 billion parameters, it reduces the memory bandwidth requirement, allowing it to achieve over 50 tokens per second on consumer unified memory architectures like the Strix Halo.
Qwen3.6 27B
For solo developers with a 24GB card, Qwen3.6 27B handles daily coding tasks without saturating memory. Alibaba released this dense model in April 2026 under the Apache 2.0 license. It requires roughly 17GB of VRAM at Q4 precision, meaning it fits comfortably on a single RTX 3090, 4090, or 5090.
It is a dense 27B model that holds its own against much larger architectures. Ollama runs it perfectly for standard text and coding workflows using community GGUFs. If you want to use its native multimodal vision capabilities, you need the separate mmproj vision file, which requires serving it via llama.cpp or LM Studio.
# Serving Qwen3.6 27B for coding (text-only) with llama.cpp
# -ngl 99 offloads all layers to the GPU for maximum speed
# -c 32768 sets the context budget to 32k tokens
./llama-server \
-m models/Qwen3.6-27B-Q4_K_M.gguf \
-c 32768 \
-ngl 99 \
--port 8080
# Note: Add --mmproj models/Qwen3.6-27B-mmproj-f16.gguf
# only if you specifically want to pass image inputs.Devstral Small 2
Mistral built Devstral Small 2 specifically for multi-file tool-using work. It is a 24 billion parameter dense model with a 256,000 token context window. It fits a 24GB card at Q4 precision and operates under the Apache 2.0 license.
If you are wiring a local model into a Python script that needs to execute shell commands, Devstral Small 2 follows JSON schema constraints and function signatures reliably. It is a strong variety pick for agentic frameworks when you need an alternative to the Qwen architecture.
gpt-oss
OpenAI released open weights under the gpt-oss lineage. The gpt-oss-20b model has 21 billion total parameters and activates 3.6 billion. It requires roughly 14GB of VRAM and fits a 16GB card. The larger gpt-oss-120b requires 80GB-class hardware.
This brings the OpenAI lineage to local hardware. The model is strong at reasoning through a problem before writing code. It generates an internal chain-of-thought trace, working out the logic of a complex algorithm before outputting the final implementation.
The One They All Get Wrong: Autocomplete
The entire list above focuses on chat and agent models. None of them are the right tool for the task developers perform most frequently. Tab-completion requires a different approach entirely.
Autocomplete relies on fill-in-the-middle (FIM). FIM is a specific training objective that teaches the model to predict the code between what is above and below your cursor. Standard causal language models only know how to predict the next word based on what came before it. FIM tokenizes the file into a prefix, a suffix, and a middle section, training the model to bridge the gap. You cannot use a trillion-parameter agent for this. You need a small fast model wired directly into your editor predicting tokens in milliseconds.
Codestral 2 is the open answer. Mistral shipped it in April 2026 under the Apache 2.0 license with native FIM support. It takes 16 to 24GB of VRAM to run.
You wire this into Continue.dev, an open-source extension for VS Code and JetBrains. This setup matches Copilot tab-completion locally with lower latency and no subscription. If you have smaller hardware, Qwen2.5-Coder 14B is the alternative, requiring roughly 9.5GB of VRAM at Q4.
The configuration requires setting the specific role to autocomplete so the editor knows to format the prompt using the correct FIM tokens.
# ~/.continue/config.yaml
models:
- name: Codestral 2
provider: ollama
model: codestral:latest
roles:
- autocomplete
autocompleteOptions:
maxPromptTokens: 2048
debounceDelay: 250Which Model for Which Job
The same model is rarely the answer to two different jobs. You have to match the architecture to the workflow. The table below breaks down the best open picks based on the specific coding task you need to accomplish.
What Your Hardware Can Run
The rule of thumb for local deployment is that at Q4 precision, you need roughly 0.6GB of VRAM per one billion parameters. A 24GB card holds a 32B model with enough room left over for a healthy context window.
Unified memory architectures works differently. A Mac Studio with 64GB or 96GB of memory, or an AMD Strix Halo box with 128GB, can run models that would otherwise require a dedicated server with multiple enterprise GPUs.
Closing
The choice falls out naturally once you define your hardware constraints and your specific workflow. Find your memory capacity in the table, download the weights tonight, and wire the right tool directly into your editor.
if this helped, clap 👏 so others can find it too — and if you want the shorter, sharper cuts of stuff like this, I also post notes on substack. Further reading:
Mac Mini M4 vs RTX 5090 vs Cloud GPUs for Local AI in 2026: The machine to run these models on, compared by budget.
Kimi K3 Is the Biggest Open Source Model Ever. Almost No One Can Run It.: The frontier open model nobody has the hardware to self-host.
I Tested Gemma 4 vs the Qwen Coders on 16GB: The Bottleneck Was Never the Model: Real benchmarks on a constrained card, where memory, not model, decides.
Run a Useful Local LLM in 30 Minutes (Coding, RAG, Voice): The end-to-end setup once your model and hardware are chosen.