Best Open-Weight Coding Models in 2026: DeepSeek vs Qwen vs Kimi vs GLM

For most of the last few years, the strongest coding models were closed and priced accordingly. That has changed. A cluster of Chinese labs now ships genuinely open-weight models that you can download, self-host, fine-tune, or call through an API for a small fraction of what the closed frontier costs, and the gap in day-to-day coding quality has narrowed to the point where many teams no longer feel they are compromising. If you are choosing an open or cheap model in 2026, four families dominate the conversation: DeepSeek, Qwen, Kimi and GLM (Z.ai).

Quick comparison

Prices move constantly and vary by provider, so treat the cost column as a rough guide and confirm current rates before you commit. All four publish weights you can run yourself, which means the cheapest possible cost is your own hardware.

DeepSeek

DeepSeek is the model that made "open-weight and cheap" a serious proposition. Its models are released under the permissive MIT license, weights are on Hugging Face, and its official API is among the least expensive anywhere, typically a few cents per million input tokens with output priced modestly higher. The lineup pairs a large Mixture-of-Experts base line (the V-series, now with very long context) with a reasoning line descended from R1, the release that popularized reinforcement-learned chain-of-thought in an open model.

Strengths: excellent price-to-quality on general coding, solid reasoning for debugging and algorithmic work, and a huge context window on the newer models for working across large codebases. The permissive license makes it safe for commercial products, and broad third-party hosting means you are not locked to one endpoint.

Real limits: the reasoning models can be verbose and slower, and token-heavy "thinking" can erode the cost advantage on long agent runs. Tooling and IDE integrations are good but less polished than the closed incumbents, and rapid version churn means you should pin a specific model in production.

Access and pricing: use it free in the DeepSeek chat app, or via the official API and many resellers; self-host the weights from Hugging Face for zero per-token cost.

Qwen

Qwen, Alibaba's family, wins on breadth. It spans tiny models that run on a laptop up to very large MoE systems, with dedicated coder variants, and the open-weight releases are under the business-friendly Apache 2.0 license. Weights are published on both Hugging Face and ModelScope, and the hosted API runs on Alibaba's DashScope platform, with a Qwen Chat interface for casual use.

Strengths: the sheer range means you can match model size to your budget and latency needs, and the coder-tuned variants are strong at code completion, tool calling and agentic workflows. Apache 2.0 is about as clean as open licensing gets for commercial use, and the smaller models are genuinely practical to self-host, which is a big deal for teams that want local, private inference.

Real limits: the naming can be confusing given how many variants and generations exist, so it is easy to pick the wrong size or an older checkpoint. Quality scales with model size as you would expect, so the small local models trade accuracy for portability. Verify which specific variant you are calling, especially through third-party hosts.

Access and pricing: free to self-host under Apache 2.0; hosted via DashScope and numerous providers at low per-token rates; try it in Qwen Chat.

Kimi

Kimi, from Moonshot AI, is built around its K2 line, a trillion-parameter-class Mixture-of-Experts model with a comparatively small number of active parameters per token, released open-weight under a Modified MIT License. The modified terms are permissive for the vast majority of users, adding an attribution requirement only at very large scale (very high monthly active users or revenue). Moonshot has leaned hard into agentic, long-horizon coding, with coding-focused and "thinking" variants aimed at multi-step software tasks rather than one-shot snippets.

Strengths: this is a standout for long, tool-using agent runs, the kind where a model has to plan, edit multiple files, run commands and stay coherent over many steps. It pairs well with agent CLIs and handles end-to-end tasks across languages. When your workload is "finish this feature," not "complete this line," Kimi is a strong pick.

Real limits: the flagship is large, so self-hosting demands serious hardware, and API pricing sits above the very cheapest options here. As with the others, verify licensing terms if you operate at massive scale, and pin versions because the coding variants iterate quickly.

Access and pricing: free in the Kimi chat app, API via Moonshot's platform at low-to-mid rates, weights on Hugging Face under the moonshotai account.

GLM (Z.ai)

GLM, from Zhipu AI under the Z.ai brand, has become a favorite for developers who want a capable coding model behind a predictable, cheap bill. The GLM models are open-weight under the MIT license, and Z.ai is known for aggressive pricing, including flat-rate coding subscription plans that make heavy agent usage affordable in a way per-token billing often does not.

Strengths: GLM is explicitly tuned to work well inside coding agents and CLIs, and it holds up on real-world engineering tasks while undercutting closed competitors dramatically on cost. The MIT license keeps it commercially clean, and the flat coding plan is a genuinely different pricing model that suits teams running many requests per day.

Real limits: on the very hardest reasoning and edge-case problems, the closed frontier still has an edge, and as with every model here you should validate on your own stack rather than trusting a leaderboard. Version cadence is fast, so treat any specific benchmark claim you read as a snapshot.

Access and pricing: use it via Z.ai chat and the API, subscribe to a coding plan for flat-rate agent use, or self-host the MIT-licensed weights.

Which should you pick?

All four are good enough that you will not go wrong, and the right answer depends on how you work and where your costs concentrate.

• Pick DeepSeek if you want the best overall price-to-quality and strong reasoning, and you are happy calling a cheap API or self-hosting.
• Pick Qwen if you value a wide range of sizes, clean Apache 2.0 licensing, and practical local self-hosting for privacy or offline use.
• Pick Kimi if your work is long-horizon, multi-step agentic coding where a model must plan and edit across many files and steps.
• Pick GLM (Z.ai) if you run high-volume coding agents and want predictable, flat-rate pricing that keeps the bill low.

A sensible strategy is to route: a small local Qwen for cheap completions, DeepSeek or GLM for the bulk of API work, and Kimi for the gnarly agent runs.

FAQ

Are these models free? They are free to run yourself because the weights are openly published, so your only cost is hardware. Hosted APIs are paid but very cheap compared with closed frontier models, and each vendor offers a free chat app for casual use.

Are they really open source? They are open-weight, which is not quite the same as open source. DeepSeek, Qwen and GLM use permissive licenses (MIT or Apache 2.0), and Kimi uses a Modified MIT License with an attribution clause that only bites at very large scale. Training data and full pipelines are generally not released.

What about data privacy with Chinese models? If you call a vendor's hosted API, your data is processed on their infrastructure under their terms, the same concern you would weigh with any cloud provider. The key advantage of these models is that you can avoid that entirely by self-hosting the open weights on your own hardware, keeping prompts and code fully in-house.