Jul 1, 2026

Open-Source LLM Licenses 2026: MIT vs Apache vs Llama

By AIFoss · 13 min read

llmlicenseselfhostedollamamoeapachemit

TL;DR: The cleanest-licensed open models in 2026 — GLM-5.1 and DeepSeek V4 (both MIT) — are also the ones no consumer GPU can run. The models you can actually self-host on one card, Qwen3.6-35B-A3B and Gemma 4, are Apache 2.0. Llama 4 is the odd one out: it fits your hardware but carries the only license in this group with strings attached.

	Qwen3.6-35B-A3B	Gemma 4 26B-A4B	Llama 4 Scout	GLM-5.1	DeepSeek V4-Flash
License	Apache 2.0	Apache 2.0	Llama 4 Community	MIT	MIT
Commercial use	Unrestricted	Unrestricted	Under 700M MAU	Unrestricted	Unrestricted
Runs on one consumer GPU?	Yes (24GB)	Yes (16GB)	With quant	No	No
SWE-bench	73.4% Verified	~52% (31B)	—	58.4% Pro	79.0% Verified
The catch	Long context eats VRAM	Smaller ceiling	Attribution + MAU cap	Datacenter-only	Datacenter-only

Honest take: If you want a frontier-adjacent coding model that fits one 24GB card and has a license your lawyer will never ask about, Qwen3.6-35B-A3B is the pick. Everything cleaner on benchmarks needs a server; everything else on consumer hardware is either smaller or licensed with an asterisk.

Most “best open LLM” roundups rank models by benchmark score and stop there. For a self-hoster that ranking is misleading, because the top of the leaderboard is full of trillion-parameter models you can’t load, licensed under terms you may not have read. The two questions that actually decide what you deploy are: can I run it on the hardware I own, and can I use it commercially without a legal review. This compares five of 2026’s most-discussed open models on exactly those axes.

Why the license matters more than the benchmark

An “open weights” release is not automatically free software. There is a real spectrum, and where a model sits on it changes what you’re allowed to build.

MIT / Apache 2.0 — genuinely permissive. Use commercially, modify, redistribute, fine-tune and sell the result, no revenue cap, no user cap, no phone-home. Apache 2.0 adds an explicit patent grant and a “state your changes” clause; MIT is even shorter. For a business self-hosting a model, these are the only two labels that mean “no strings.”
Vendor community licenses (Llama 4 Community, and formerly Gemma) — commercial use is allowed, but with conditions: attribution strings, acceptable-use policies, and in Llama’s case a monthly-active-user ceiling above which you must negotiate a separate license with Meta.
“Open weights, non-commercial” — you can download and tinker, but shipping a product is off the table. Flux.1 Dev and MiniMax’s community license live here. None of the five below fall into this bucket, which is why they made the shortlist.

The distinction isn’t academic. If you build a product on Llama 4 and it takes off past 700 million monthly active users, you are contractually required to stop until Meta grants you a license. That will never bind a solo developer, but it is exactly the kind of clause that gets a self-hosted model banned in enterprise procurement. MIT and Apache have no equivalent. Our open-source LLM licensing guide breaks the full legal taxonomy down field by field.

The five contenders

Qwen3.6-35B-A3B — Apache 2.0, and it fits

Alibaba released Qwen3.6-35B-A3B on April 16, 2026 under a plain Apache 2.0 license. It’s a 35B-parameter Mixture-of-Experts model that activates roughly 3B parameters per token, so it loads like a 35B model but generates at the speed of a 3B one. On SWE-bench Verified it scores 73.4%, which is remarkable for something that runs on a single 24GB card at Q4_K_M (~21GB of weights). Native context is 262K, extensible toward 1M.

Apache 2.0 here means what it says: no MAU cap, no attribution requirement beyond the standard license notice, commercial fine-tuning allowed. For the intersection of “clean license” and “runs on hardware I own,” nothing else in this list matches it. Full setup steps are in our Qwen3.6-35B-A3B local setup guide.

Gemma 4 — the license that quietly changed

This is the one worth double-checking, because Gemma’s history is the reason. Every Gemma generation before this shipped under Google’s custom Gemma Terms of Use — a permissive-but-not-OSI license with usage carve-outs that made enterprise legal review painful. Gemma 4 dropped it. As of the March 2026 release, Gemma 4 weights ship under Apache 2.0 for the first time, confirmed by Google’s own Open Source Blog and the HuggingFace model cards.

That is a genuine change, not a rewording. Apache 2.0 has no acceptable-use policy attached, no revenue threshold, and no requirement to accept terms before downloading. If you evaluated Gemma in 2024 or 2025 and passed on it for licensing reasons, the 2026 line is a different legal proposition.

The lineup runs E2B, E4B, 12B, 26B-A4B (a 4B-active MoE), and 31B dense, all multimodal across text, image, audio, and video with a 256K context window. The 26B-A4B fits in about 15GB after Google’s June 5 quantization-aware-training (QAT) checkpoints landed. One caveat that bites people: do not hand-convert those QAT checkpoints to Q4_0 — a scale mismatch tanks accuracy. Use the pre-built GGUFs. We cover the exact commands in the Gemma 4 QAT self-hosting guide.

GLM-5.1 — MIT, frontier, and completely impractical at home

Z.ai’s GLM-5.1 (released April 7, 2026) is the cleanest license paired with the highest coding score in the group: MIT, and 58.4% on SWE-Bench Pro — the first open model to top that leaderboard, ahead of several proprietary flagships. It’s a ~744B-parameter MoE with roughly 40B active per token.

The problem is size. Even at a 2-bit Unsloth dynamic GGUF, running GLM-5.1 locally wants a 24GB GPU plus around 256GB of system RAM for offload, and it crawls. MIT gives you every right to deploy it commercially; physics gives you a datacenter bill. For most people the Z.ai API free tier is the sane entry point, and RunPod is the sane self-host path — see the GLM-5.1 review for the full hardware math. Z.ai has since shipped GLM-5.2 (June 13, 2026, also MIT, 62.1% SWE-Bench Pro), with the same “great license, needs a cluster” tradeoff.

DeepSeek V4 — MIT giant, with a runnable-ish sibling

DeepSeek’s V4 preview arrived April 24, 2026 as two MIT-licensed models. V4-Pro is 1.6T parameters (49B active) and scores 80.6% on SWE-bench Verified — genuinely frontier, and at ~862GB of weights, genuinely a datacenter model. The one self-hosters should care about is V4-Flash: 284B total / 13B active, 79.0% on SWE-bench Verified (only 1.6 points behind Pro), MIT-licensed, 1M context.

V4-Flash is still not a single-consumer-GPU model — 284B of weights is a multi-GPU or heavily-offloaded workload — but the MIT license means you can deploy it in your own infrastructure with zero legal friction, which is the entire pitch. Details in the DeepSeek V4 Pro review.

Llama 4 — fits your hardware, carries the only real strings

Meta’s Llama 4 line is the interesting outlier. Scout (109B total / 17B active, 16 experts, 10M context) actually quantizes down to run on high-end consumer hardware, and Maverick (400B / 17B active, 128 experts) is a single-server model. Both are natively multimodal. On paper this is the “runnable frontier MoE” story the MIT giants can’t tell.

The asterisk is the Llama 4 Community License. Commercial use is allowed below 700 million monthly active users — cross that, and you must request a separate license from Meta before you may keep using it. It also requires “Built with Llama” attribution, carries an Acceptable Use Policy, and restricts multimodal use for entities domiciled in the EU. None of that is Apache or MIT. For a hobbyist it’s invisible; for a company that wants a model with no downstream conditions, it’s a reason to pick something else. Meta’s own text is explicit that this is “not OSI-open.”

The hardware reality: a clean license you can’t load isn’t much use

Here’s the pattern that the benchmark-only roundups miss. Plot license freedom against consumer runnability and the two barely correlate.

Model	License freedom	Min. realistic hardware	One-GPU (24GB) viable?
Gemma 4 26B-A4B	Apache 2.0 (max)	16GB GPU (QAT)	Yes, comfortably
Qwen3.6-35B-A3B	Apache 2.0 (max)	24GB GPU (Q4_K_M)	Yes
Llama 4 Scout	Community (conditional)	24GB+ w/ aggressive quant	Barely
DeepSeek V4-Flash	MIT (max)	Multi-GPU / big RAM offload	No
GLM-5.1	MIT (max)	24GB GPU + 256GB RAM (2-bit)	Technically, painfully

The two models that are both maximally free and comfortably single-GPU are the two Apache 2.0 mid-size MoEs: Gemma 4 26B-A4B and Qwen3.6-35B-A3B. The MIT models win the license-plus-benchmark axis but lose the hardware axis outright. If your priority is running frontier-class MIT weights on your own metal, budget for a multi-GPU box or rent one — RunPod is the usual middle ground between local and a full cloud API, and runaihome.com has the consumer GPU hardware breakdown if you’re speccing a box for tok/s rather than license terms.

Ollama availability, verified

All five have a home in the Ollama library as of mid-2026 (Ollama v0.30.x), though the big MoEs are there more for completeness than practicality:

# Apache 2.0, single-GPU friendly — the ones you'll actually run
ollama run qwen3.6:35b-a3b
ollama pull gemma4:26b

# MIT / Community — pullable, but check your VRAM first
ollama pull llama4:scout
ollama pull glm-5.1
ollama pull deepseek-v4        # Pro; datacenter-class

One trap worth naming: some of these have a :cloud tag (for example qwen3-coder-480b:cloud). Those do not run on your GPU — they route inference to Ollama’s own servers, which defeats the point of self-hosting for privacy. Confirm you pulled a local tag and check ollama ps shows VRAM in use.

A problem you’ll actually hit: the QAT accuracy cliff

The most common self-inflicted wound with these models isn’t the license — it’s quantization. When Gemma 4’s QAT checkpoints dropped, the obvious move was to convert them to a standard Q4_0 GGUF and load it. On the 26B-A4B, that naive conversion dropped measured accuracy from ~85.6% to ~70.2% on internal evals, because a QAT checkpoint is trained for a specific quantization scheme and a mismatched one throws its scales off.

The fix is not to convert at all. Pull the pre-built Unsloth UD-Q4_K_XL GGUFs for Ollama/llama.cpp, or Google’s w4a16 compressed-tensors build for vLLM:

# Correct: use the pre-quantized checkpoint, don't roll your own Q4_0
ollama pull hf.co/unsloth/gemma-4-26b-a4b-GGUF:UD-Q4_K_XL

Same class of mistake shows up with the MIT giants: people pull a GLM-5.1 GGUF, discover it needs 256GB of RAM offload, and blame the model when the real issue is trying to run a 744B MoE on a desktop. The license lets you; the hardware doesn’t want you to.

When NOT to reach for these

Skip GLM-5.1 and DeepSeek V4-Pro for local self-hosting. MIT or not, they are datacenter models. Use their APIs or rent GPUs. Self-hosting them on a home rig is a science project, not a deployment.
Skip Llama 4 if a clean license is a hard requirement. It’s a strong, runnable model, but the MAU cap, attribution string, and EU multimodal carve-out mean it fails a strict “no conditions” test that Apache and MIT pass. If you’re choosing purely on legal cleanliness, Qwen3.6 or Gemma 4 dominate it.
Skip the 35B-class models entirely if you’re on 8GB. Qwen3.6-35B-A3B and Gemma 4 26B-A4B want 16–24GB. On an 8GB card, drop to Gemma 4 E4B or a 7–9B model and accept the capability hit rather than fighting constant OOM.
Don’t self-host any of these if your real need is a handful of requests a day. A free API tier will be faster, cheaper, and lower-maintenance. Self-hosting earns its keep on privacy, volume, or data sovereignty — not convenience.

Verdict

For the self-hoster who weighs license freedom and consumer hardware equally, the ranking is clear and it is not the benchmark ranking:

Qwen3.6-35B-A3B — Apache 2.0, runs on one 24GB GPU, 73.4% SWE-bench Verified. The best all-round answer.
Gemma 4 26B-A4B — Apache 2.0, runs on 16GB, multimodal, now genuinely OSI-clean after the license change. Pick this over Qwen if you want smaller or need vision/audio.
DeepSeek V4-Flash — MIT and frontier-class, if you have multi-GPU infrastructure. The best license-plus-capability story once hardware stops being the constraint.
GLM-5.1 — MIT and the highest coding score, but effectively cloud-only at home. Great via API, painful locally.
Llama 4 Scout — the most runnable frontier MoE, held back only by the one non-free license in the group. Fine unless license cleanliness is your deciding factor.

The headline for 2026: the open-model gap to proprietary frontier models has nearly closed, but the practical gap for self-hosters is now about hardware, not licenses. Four of these five are MIT or Apache. The question stopped being “is there a free-enough license” and became “which free model fits my GPU.”

FAQ

Is Gemma 4 really Apache 2.0? Earlier Gemma wasn’t. Yes. Gemma 4 (March 2026 release) is the first Gemma generation under Apache 2.0, replacing the custom Gemma Terms of Use used by Gemma 1–3. Google’s Open Source Blog and the HuggingFace model cards both list Apache 2.0. If a source still says “Gemma Terms of Use” for Gemma 4, it’s out of date.

What does the Llama 4 700M MAU clause actually mean for me? Almost certainly nothing, unless you operate a product with more than 700 million monthly active users. Below that threshold you can use Llama 4 commercially. Above it, you must request a separate license from Meta before continuing. The clause exists to bind hyperscalers, not indie developers — but it disqualifies Llama 4 from “no-conditions” procurement checklists.

MIT vs Apache 2.0 — does the difference matter for self-hosting? For practical self-hosting, barely. Both allow unrestricted commercial use, modification, and redistribution. Apache 2.0 adds an explicit patent grant and requires you to state significant changes in redistributed copies; MIT is shorter and does neither. Either is safe for commercial deployment.

Which of these is best for a coding agent on local hardware? Qwen3.6-35B-A3B at 73.4% SWE-bench Verified, running on a single 24GB GPU. It’s the best coding score you can realistically self-host on one consumer card with a fully permissive license. For in-editor setup, see our Qwen and Continue.dev + Ollama guides.

Can I run GLM-5.1 or DeepSeek V4 on a gaming PC? Not usefully. GLM-5.1 (744B) technically loads at 2-bit with 24GB VRAM plus ~256GB system RAM, but it’s slow enough to be impractical. DeepSeek V4-Pro (1.6T, 862GB) needs a datacenter outright. V4-Flash (284B) is multi-GPU. Use their APIs or rent GPUs for these.

Sources

Was this article helpful?