The best open source coding models right now are GLM 5.3 Flash, DeepSeek V4.1 Flash, and GPT-OSS-120B for most production API work. DeepSeek V4 Pro and Kimi K2.6 suit the hardest agent loops, and Qwen 3.6 or Gemma 4 31B fit when the model has to run on hardware you control. A good pick does three things. It keeps its footing across dozens of tool calls, it fits your context and memory budget, and it ships under a license your legal team accepts.
The trouble is that every lab claims frontier coding scores, and a leaderboard rank rarely tells you whether a model will survive your repo, your harness, or your budget. Open-weight releases also move fast, so a list from six months ago is already out of date.
This guide ranks eight models by how well they fit real buying and integration decisions. Each entry covers coding strengths, the reader it suits, and license and access. At Geodd we serve many of these models through an OpenAI-compatible API. Where we host one, we link its model page and leave pricing there, because prices change.
How to judge open source coding models
Judge an open source coding model on agentic benchmarks first, then on a short test with your own code. Public scores narrow the field to a handful of candidates, but only your repo and your tooling pick the winner.
The benchmarks worth reading
Five benchmarks cover most of what a coding model has to do, and each answers a different question. Read them together, because a model can lead one and trail another.
| Benchmark | What it tests | What a high score tells you |
|---|---|---|
| SWE-Bench Verified | Resolving real GitHub issues in real repositories | The model can read a codebase, edit several files, and pass tests |
| SWE-Bench Pro | A harder issue-resolution benchmark | Staying power on longer, messier tasks |
| Terminal-Bench | Completing tasks in command-line environments | Reliable shell and tool use inside an agent loop |
| LiveCodeBench | Fresh competitive-programming style problems | Raw algorithmic coding with less contamination risk |
| Aider Polyglot | Code editing across several languages | Clean edits and format discipline outside Python |
For agentic work, weight SWE-Bench-style and terminal benchmarks most heavily. They reward the loop you actually run: read, edit, test, recover. LiveCodeBench rewards puzzle solving, which matters less when your job is fixing a service.
Why scores alone mislead
Vendor-reported scores depend on the harness around the model. The same weights can post very different results with a different prompt scaffold, tool schema, or retry policy, so a published number is a ceiling, not a promise. Contamination adds noise too, because older benchmarks leak into training data over time.
A benchmark score tells you what a model did in someone else's harness, not what it will do in yours.
Active parameters deserve a second look as well. Most models here are mixture-of-experts, so a model with 13B or 49B active parameters still needs every expert's weights in memory. Cheap per token does not mean cheap to host.
How we ordered this list
We ranked by fit for production API use first: long-context support, tool calling, structured output, and availability behind an OpenAI-compatible endpoint. Benchmark strength came second and license third. We left score tables out on purpose. Numbers shift with each point release and each lab's harness, so our claims are qualitative and tied to the exact version named.
One terminology note. Searches use open-source and open-weight interchangeably, but most entries here are open-weight: the trained weights are public, while training data and full pipelines often are not. Licenses range from MIT and Apache 2.0 to custom community terms, so each entry states what we could verify and points you to the model card for the rest.
1. GLM 5.3 Flash
GLM 5.3 Flash is our first pick for teams that want a fast, long-context coding model behind a hosted API. It comes from Z.AI's GLM line, a consistent leader in agentic coding comparisons, and it is one of the best open source coding models for debugging and everyday assistance.
Coding strengths
Geodd lists GLM 5.3 Flash for coding assistance, software debugging, reasoning, and long-context document analysis, with streaming and structured-output support. The full GLM-5.3 model is a separate release: a mixture-of-experts model of roughly 750B parameters with about 40B active, a 1M-token context window, and three thinking-effort levels, where Z.AI recommends the highest for coding. Its gains over GLM-5.2 came entirely from post-training on an identical base.
Treat GLM 5.3 Flash as the practical, hosted-first entry point to the GLM 5.3 generation.
Keep those figures apart. The specs above belong to full GLM-5.3, and the Flash endpoint's own limits are on its model page. The features that matter day to day:
- Streaming responses for editor and chat interfaces
- Structured output for tool pipelines and code-review bots
- Long-context analysis of large files and design documents
Who it suits
It suits product teams adding a coding assistant or debugging helper to an application, and teams that want one model for code and long documents. If you need a single hosted endpoint that handles reasoning and code without cluster work, start here.
- Choose it when you want low-friction API access for assistants and review tools.
- Skip it when you need to self-host on one GPU, or when you need the largest reasoning budget available.
License and access
Z.AI released GLM-5.2 under the MIT license, but confirm the license on the GLM-5.3 model card before you build on it. For hosted access, see GLM 5.3 Flash on Geodd for token pricing, SDK examples, and coding-agent integration guides.
Do not mix this page up with GLM 5.2, which has its own endpoint and its own limits.
2. DeepSeek V4.1 Flash
DeepSeek V4.1 Flash is the pick when long context and serving cost matter more than the last benchmark point. Providers pitch it at coding agents that read a lot of code and write comparatively little, which makes it a strong open source LLM for coding at volume.
Coding strengths
The V4 generation uses compressed attention to cut KV-cache memory at long context, which is why DeepSeek models stay affordable when an agent stuffs a whole repository into the prompt. DeepSeek's V4 Flash tier is a 284B-parameter mixture-of-experts model with 13B active and a 1M-token window. Those are V4 Flash figures, so read the V4.1 Flash page for its exact limits.
Long prompts are where Flash-tier models earn their keep, because prefill cost dominates agent bills.
Geodd lists V4.1 Flash for reasoning and long-context applications, with streaming support and token pricing.
Who it suits
It suits teams running high-volume agents: pull request reviewers, repository Q&A, test generators, and refactoring bots that re-read context on every step. Cost per run is usually the deciding factor here, and Flash tiers exist for that reason.
- Choose it when prompts are long and runs are frequent.
- Skip it when a task needs the deepest reasoning available and cost is secondary. DeepSeek V4 Pro, covered below, is the bigger sibling.
License and access
The V4 family was released under the MIT license, which allows commercial use and fine-tuning. Confirm the V4.1 terms on the model card. DeepSeek V4.1 Flash on Geodd lists token pricing, context limits, and data handling.
DeepSeek V4 Flash is a different model with its own page, so keep the two apart when you compare providers.
3. GPT-OSS-120B
GPT-OSS-120B is the best open source coding model on this list for teams that want a permissive license and a simple deployment. OpenAI released it as an open-weight reasoning model, and it runs on a single 80 GB GPU.
Coding strengths
It is a mixture-of-experts model with roughly 117B total and 5.1B active parameters, a 128K-token context window, and an adjustable reasoning effort (low, medium, or high). Tool calling and structured output work through the same chat interface you already use, which keeps agent code simple. Baseten reports it is among the cheapest 120B-class models to serve.
GPT-OSS-120B trades the longest context for the easiest path to production.
Its limits are real. The window is smaller than the 1M-token models above, and it will not match the largest models on the hardest multi-hour agent tasks.
Who it suits
It suits teams that value operational simplicity: one-GPU self-hosting, predictable latency, and a license that needs little legal review. It is also a sensible default for coding assistants where each task touches a few files rather than a whole monorepo.
- Choose it when you want a strong general coder with modest hardware needs.
- Skip it when you routinely need context beyond 128K tokens.
For laptop-class or small-GPU use, the smaller sibling GPT-OSS-20B needs roughly 16 GB of memory. Do not assume the two models share identical capabilities.
License and access
GPT-OSS ships under Apache 2.0, which permits commercial use and modification. GPT-OSS-120B on Geodd covers token pricing, regional endpoints, data handling, SDK examples, and a coding-agent integration prompt. Check the page for the regions the endpoint supports if data residency matters to you.
4. DeepSeek V4 Pro
DeepSeek V4 Pro is the strongest DeepSeek option for complex agentic coding, and one of the top open source AI models for coding overall. Pick it when task difficulty, not price per token, is your constraint.
Coding strengths
V4 Pro is a mixture-of-experts model with 1.6T total and 49B active parameters, pretrained on more than 32T tokens, with a 1M-token window. It offers three inference modes: non-think for routine edits, think high for deliberate reasoning, and think max for the hardest problems. That lets you tune latency against quality per request without switching models.
V4 Pro is the model DeepSeek itself reportedly uses for day-to-day agentic coding, which is a stronger signal than any single score.
DeepSeek says the model needs about 10% of the KV cache that V3.2 required at 1M tokens, so long sessions stay practical.
Who it suits
It suits teams with demanding agent workloads: multi-file migrations, long debugging sessions, and orchestrator roles that delegate to cheaper models. Pairing V4 Pro as planner with a Flash model as worker is a common cost-control pattern.
- Choose it when failed runs cost more than tokens.
- Skip it for self-hosting unless you have cluster-scale GPUs. A 1.6T-parameter model is not a single-server job.
License and access
DeepSeek released V4 under the MIT license, so commercial use and fine-tuning are open. Hosting it yourself is a serious infrastructure commitment, which is why most teams call it through an API. See DeepSeek V4 Pro on Geodd for token pricing, tool-calling and structured-output support, and regional availability.
5. Kimi K2.6
Kimi K2.6 is the best open-weight coding model on this list for parallel sub-agent workflows. Moonshot AI built it for long autonomous coding sessions, and it rewards teams that invest in a proper harness.
Coding strengths
K2.6 is a mixture-of-experts model with about 1T total and 32B active parameters, a 256K-token context window, and a vision encoder for image input. Moonshot reports it can split work across up to 300 sub-agents over 4,000 coordinated steps. A preserve_thinking mode keeps reasoning traces across turns, which improves reliability in agent loops.
K2.6 shines when the work parallelizes, and it is less of a bet for one long, ambiguous plan.
It generalizes well across languages, including niche ones like Zig. Moonshot recommends its Kimi Code CLI as the matching agent harness.
Who it suits
It suits teams building multi-agent coding systems, UI generation tools, and background agents that run unattended. Newer Moonshot releases exist, including K2.7 Code and K3, so check which version a provider actually serves.
- Choose it for parallel, well-scoped tasks across a codebase.
- Skip it when you need a context window beyond 256K tokens.
License and access
K2.6 uses a modified MIT license. The only change: products above 100M monthly active users or $20M in monthly revenue must display "Kimi K2.6" in the interface. For hosted use, Kimi K2.6 on Geodd lists pricing, context limits, tool calling, and structured outputs. Do not use that page for other Kimi versions.
6. GLM 5.2
GLM 5.2 is the proven, MIT-licensed choice for repository-scale agents. It is the best open-source LLM for coding on this list when a fully permissive license is a hard requirement and you want a long-context model with strong software-engineering results.
Coding strengths
It is a mixture-of-experts model of roughly 750B parameters with about 40B active, a 1M-token context window, and DeepSeek Sparse Attention for efficient long-context inference. Z.ai reports leading results on SWE-Bench Pro and Terminal-Bench 2.1, some ahead of GPT-5.5 and Claude Opus 4.8. Treat vendor-reported claims as directional until you run your own tests.
A 1M-token window lets an agent hold a mid-sized repository in context instead of compacting constantly.
IndexShare, a long-context optimization, reuses one sparse-attention indexer across groups of four layers. Z.ai says it cuts per-token compute by roughly 2.9x at full context.
Who it suits
It suits enterprises that fine-tune or redistribute models and teams whose agents work across large repositories. It also makes a stable baseline while you evaluate the newer GLM 5.3 generation.
- Choose it when MIT licensing and long context both matter.
- Skip it when you want the lighter, faster Flash-style endpoint.
License and access
GLM 5.2 is released under the MIT license, which allows commercial use, modification, and distribution. GLM 5.2 on Geodd covers published pricing, tool-calling and structured-output support, context limits, and integration examples. It is the right page for long-horizon agent work on this version only.
7. Qwen 3.6
Qwen 3.6 is the best open source coding LLM for people who run models locally. Alibaba's family includes a 27B dense model and a 35B-A3B mixture-of-experts model, and both run on hardware that fits under a desk.
Coding strengths
Baseten reports that the Qwen 3.6 27B model beats the previous 397B open-source Qwen flagship on every major coding benchmark despite its small size. The family brings repo-level reasoning with few mid-task corrections, solid frontend and devops performance, and native image and video input in a single checkpoint. The 35B-A3B variant activates only about 3B parameters per token, so it generates quickly.
Qwen 3.6 proves that a model small enough to self-host can still handle real repository work.
Harness quality matters more with smaller models. Give them structured tools and tight prompts.
Who it suits
It suits individual developers, privacy-sensitive teams, and local-first setups that cannot send code to an external API. It is also a good second model for a cheap worker role inside a larger agent system.
- Choose it when your hardware budget is one workstation GPU or a modest server.
- Skip it for the hardest multi-hour agent tasks, where the large models still pull ahead.
License and access
Weights are published for self-hosting, and the 35B-A3B model still needs all its weights in memory even though few are active per token. Confirm the exact license on the model card for the checkpoint you download, since Qwen releases vary. Running locally with an OpenAI-compatible server such as vLLM or llama.cpp lets you reuse the same client code you would point at a hosted endpoint.
8. Gemma 4 31B
Gemma 4 31B is the best pick for a permissive license on a single datacenter GPU. Google's dense model fits on one 80 GB H100, and its Apache 2.0 license makes it easy to ship.
Coding strengths
It is a dense model, so every parameter works on every token. It supports a 256K-token context window, native function calling and system prompts, and strong results among open-weight models of similar size on coding and reasoning benchmarks such as LiveCodeBench and Codeforces. Its attention design alternates local sliding-window layers with global layers to keep memory manageable.
Gemma 4 31B has a lower ceiling than the giant mixture-of-experts models, but a much lower operating cost.
The 31B model does not accept audio. The smaller E2B and E4B variants handle audio, and a 12B variant targets consumer GPUs.
Who it suits
It suits teams with strict data residency needs, multilingual products, and developer tools where each task touches a handful of files. It is a dependable choice for test writing, refactoring, and single-file generation.
- Choose it for one-GPU deployment, multilingual code comments, or tool-using assistants.
- Skip it for long-horizon orchestration across a large codebase.
License and access
Gemma 4 ships under Apache 2.0, which supports commercial use and fine-tuning on proprietary data. Quantized builds shrink memory needs further, at some cost in quality. For a hosted endpoint, see Gemma 4 31B on Geodd for pricing, context limits, and tool-calling support. The page covers this size only, not other Gemma variants.
Which open source coding model fits your setup
The best open source LLM for coding is the one that matches your workload, hardware, and license limits. No single model wins every row of the table below.
Quick picks by situation
| Your situation | Start with | Why |
|---|---|---|
| Hosted API for a coding assistant or debugger | GLM 5.3 Flash | Fast, long-context, streaming and structured output |
| High-volume agents with long prompts | DeepSeek V4.1 Flash | Built for cheap long-context reading |
| One 80 GB GPU, permissive license | GPT-OSS-120B | Apache 2.0, simple deployment |
| Hardest multi-hour agent tasks | DeepSeek V4 Pro or GLM 5.2 | Largest reasoning budgets, 1M context |
| Parallel sub-agents | Kimi K2.6 | Built for swarm-style decomposition |
| Workstation or laptop | Qwen 3.6 or GPT-OSS-20B | Small enough to run locally |
| One datacenter GPU, multilingual | Gemma 4 31B | Apache 2.0, 256K context |
Three more models are worth watching: MiniMax M3 for frontend and UI work, Kimi K3 for long autonomous sessions, and Nemotron 3 Ultra for long-running enterprise agents.
Hosted API or self-hosting
Use a hosted API when you want to switch models quickly and avoid GPU operations. Self-host when data must never leave your network or when volume is high and steady. Mixture-of-experts models save compute per token, not memory, so a 1T-parameter model needs a cluster whatever its active count.
If you want guaranteed capacity without managing a serving stack, compare serverless and dedicated inference. For raw GPU servers with your own software, see dedicated deployment. Self-hosting carries ongoing costs in engineering time, so price it honestly.
A simple way to test before you commit
Run two or three candidates against the same ten tasks from your real backlog, and score the results yourself.
- Pick tasks that vary: a bug fix, a refactor, a test suite, and a long-context question.
- Run each model through the same harness with the same tool definitions.
- Record pass rate, retries, tokens used, and wall-clock time.
- Repeat once with a cheaper model as worker and a stronger one as planner.
Because most providers speak the OpenAI protocol, switching models is a one-line change:
from openai import OpenAI
client = OpenAI(base_url="YOUR_PROVIDER_BASE_URL", api_key="YOUR_KEY")
for model in ["MODEL_ID_A", "MODEL_ID_B"]:
reply = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": "Fix the failing test in this diff: ..."}],
)
print(model, reply.choices[0].message.content)
Pick one model, then test it
The best open source coding models in 2026 are no longer a compromise. GLM 5.3 Flash, DeepSeek V4.1 Flash, and GPT-OSS-120B cover most production API needs. DeepSeek V4 Pro, GLM 5.2, and Kimi K2.6 handle the heaviest agent work, while Qwen 3.6 and Gemma 4 31B bring serious coding ability to hardware you own.
Choose by workload, hardware, and license, then verify with your own tasks. Read each model's page for version-specific limits, because neighboring versions differ in ways that break integrations.
When you are ready to compare these models side by side behind one OpenAI-compatible API, browse every model in Geodd's catalog and open the model pages for pricing and integration details.
