If you’ve spent any time picking a model for a real product, you already know the license matters almost as much as the benchmark score. A brilliant model with a restrictive license can quietly become a legal problem six months into a deployment.
Apache 2.0 has become the license everyone quietly hopes for. It lets you download the weights, modify them, fine-tune them, and ship them in a commercial product without asking anyone for permission or paying a cent in royalties. No usage caps, no “contact us for enterprise terms,” no fine print about competing products.
2026 has turned into a genuinely good year for this. A handful of labs, some famous and some you’ve probably never heard of, have released serious, competitive models under Apache 2.0. Below is a practical rundown of the ones you should actually check out.
Why Apache 2.0 Specifically?
A lot of open models aren’t really open at all. Some ship under custom licenses that restrict commercial use above a certain number of monthly active users. Others forbid using the model’s outputs to train a competing model. Apache 2.0 skips all of that. It’s a permissive, business-friendly license originally written for software, and when applied to model weights, it means you can:
- Use the model commercially, with no revenue or user caps
- Modify, fine-tune, and redistribute it
- Bundle it into a closed-source product if you want to
- Avoid any obligation to share your changes back
The tradeoff is that Apache 2.0 doesn’t require the lab to release training data or training code, so these models are technically “open weight” rather than fully open source in the strictest academic sense. For nearly everyone building a product, that distinction doesn’t matter much. What matters is whether legal will sign off, and Apache 2.0 makes that conversation short.
| Model | Developer | Parameters | Context Window | Standout Trait |
| Qwen3.5 | Alibaba | 1.5B–480B+ range | Up to 256K | Broad size range, strong multilingual reasoning |
| Mistral Large 3 | Mistral | 675B total / 41B active (MoE) | 128K | Frontier scale at open-weight cost |
| Ministral 3B | Mistral | 3B | 32K | Runs on edge devices, extremely cheap to self-host |
| Inkling | Thinking Machines Lab | 975B total / 41B active | Not fixed (effort-dial reasoning) | Built specifically for fine-tuning into specialized models |
| Apertus (8B/70B) | Swiss AI Initiative | 8B or 70B | Standard dense context | Trained on 1,800+ languages |
| Qwen3 Coder 480B-A35B | Alibaba | 480B total / 35B active | Repository-scale | Purpose-built coding agent |
| OpenVINO | Intel | N/A (toolkit) | N/A | Optimized inference on Intel/ARM hardware |
The Full List
Qwen Family (Alibaba)
Qwen has quietly become the default recommendation whenever someone asks for a clean, no-drama license. The lineup spans from small models under 2B parameters that run comfortably on a laptop, up through large mixture-of-experts variants aimed at serious reasoning and coding work. Qwen3.5 currently leads the Apache 2.0 pack on general reasoning benchmarks, and the smaller Qwen3 variants (1.5B through 32B) cover everything from on-device apps to mid-range GPU inference.
Best for: teams that want strong multilingual support and don’t want to think twice about licensing. Great starting point if you’re building anything customer-facing across non-English markets.
Mistral’s Open Lineup (Mistral Small, Nemo, Ministral, Codestral Mamba)
Mistral splits its catalog in two: a paid API for the flagship models, and a genuinely generous open tier. Mistral Small, Nemo, Ministral 8B, and Codestral Mamba all ship under Apache 2.0. Mistral Large 3, the 675B-parameter MoE flagship, is also open-weight under Apache 2.0, which is notable given how few labs open-source anything at that scale.
Ministral 3B is worth knowing about if you’re building for edge devices or anything latency-sensitive. It’s tiny and fast, and you can self-host it for free instead of paying per token.
Best for: European teams with data residency requirements, and anyone who wants a range of sizes from a single, consistent model family. Codestral Mamba is a good option if code completion is your use case.
Inkling (Thinking Machines Lab)
Released mid-2026, Inkling is one of the more interesting entries on this list, not because it tops every leaderboard (it doesn’t, and the lab says so openly) but because of how it’s built to be customized. It ships under a clean Apache 2.0 license, comes with day-one fine-tuning support through the Tinker platform, and includes recipes for adapting it into specialized models rather than treating it as a single do-everything assistant. There’s also a smaller Inkling-Small preview for teams that don’t need the full-size model.
Best for: teams planning to fine-tune heavily rather than use a model out of the box. If your roadmap involves training a dozen specialized variants for different tasks, this is built for exactly that.
Apertus (Swiss AI Initiative)
A joint effort from ETH Zurich, EPFL, and the Swiss National Supercomputing Centre, Apertus stands out for how broad its training data is. It comes in 8B and 70B parameter versions and was trained across more than 1,800 languages, which is an unusually wide net compared to most Western labs. It’s fully downloadable from Hugging Face.
Best for: projects where language coverage genuinely matters, not just English and a handful of major European languages, but low-resource languages too.
Qwen3 Coder (Alibaba)
Writing it separately from the general Qwen line because it’s purpose-built for coding agents. The 480B-A35B variant is specifically recommended when you need Apache 2.0 terms combined with large, repository-scale context windows, useful if you’re building something that needs to reason across an entire codebase rather than a single file.
Best for: coding assistants, repository-wide refactoring tools, and agentic dev workflows where license simplicity is non-negotiable.
OpenVINO Toolkit (Intel)
Not a model itself, but have to be included because it shapes how you deploy everything above. OpenVINO is Intel’s open-source toolkit for optimizing and running deep learning models, and it ships under Apache 2.0. It supports most popular model formats and is optimized for Intel hardware, though it also runs on ARM.
Best for: teams deploying open models to edge hardware or CPU-only environments where inference cost is the main constraint.
Matching Models to Use Cases
Rather than chasing whatever tops a leaderboard this week, it usually works better to start from what you’re actually building.
Multilingual Customer Support
Qwen3.5 and Apertus are the two worth testing first. Multilingual quality isn’t just about recognizing different languages; it’s about handling idioms, code-switching, and regional phrasing without sounding like a stiff translation.
Qwen3.5 benefits from Alibaba’s heavy investment in Chinese and Southeast Asian language data, so it tends to outperform Western-trained models in those regions specifically.
Apertus takes a broader approach, having been trained across more than 1,800 languages, including many low-resource ones that most labs barely touch.
If a support bot needs to handle something like Vietnamese or Swahili alongside English and Spanish, Apertus will likely do better. Its larger 70B variant needs more hardware than most teams expect for what sounds like a simple support use case.
Running on a Single GPU or Laptop
Ministral 3B and the smaller Qwen3 variants (1.5B to 8B) are built for exactly that. The appeal here goes beyond cost; it’s about latency and privacy too. A model small enough to run fully on-device skips the round-trip to a cloud API entirely, which matters for mobile apps, desktop tools, or anywhere internet access is unreliable.
The main disadvantage is capability. These smaller models noticeably underperform their larger siblings on complex reasoning or multi-step instructions, so they work best for narrow, well-defined tasks like classification or short extraction rather than open-ended conversation.
Coding Assistants
Qwen3 Coder and Codestral Mamba solve slightly different problems. Qwen3 Coder’s 480B-A35B variant is a mixture-of-experts model tuned for repository-scale context, meaning it’s built to reason across many files at once instead of just completing the current line, which suits agentic dev tools that need to understand a whole codebase’s structure.
Codestral Mamba uses a Mamba-based architecture rather than a standard transformer, giving it fast inference on long sequences, which matters more for live, low-latency completion inside an editor than for batch-style refactoring work.
Heavy Fine-Tuning Workflows
Inkling stands out because the entire release was built around that workflow. It ships with day-one fine-tuning support through the Tinker platform, published recipes in the Tinker Cookbook, and a thinking-effort dial that controls how much reasoning compute the model spends per query.
Thinking Machines Lab has said openly that Inkling isn’t meant to be the strongest general-purpose assistant on its own; it’s meant to be a strong base to specialize.
That approach saves real engineering time for anyone planning to train several narrow models off one foundation, rather than bolting a fine-tuning pipeline onto a model that was never designed for it.
Strict Data Residency Requirements
Mistral’s open lineup tends to be the practical choice, partly because of the models and partly because of the company behind them. Mistral is based in France and has built its enterprise offering, including the Forge platform for custom training, around EU data residency from the ground up.
That matters for anyone subject to GDPR or similar rules who needs assurance that data processing stays within specific jurisdictional boundaries. Companies like ASML, HSBC, and BMW already run Mistral models in production, which gives this compliance story an actual track record rather than just a theoretical one.
Edge or Low-Power Deployment
Pairing a small model like Ministral 3B with an inference toolkit like OpenVINO addresses two separate bottlenecks at once.
Model size determines the baseline memory and compute needed, while OpenVINO optimizes how efficiently that specific hardware runs it, particularly on Intel CPUs and ARM chips where a standard inference pipeline tends to perform poorly.
This pairing shows up often in retail kiosks, industrial sensors, and offline mobile apps, places where a GPU or stable internet connection isn’t guaranteed but reasonably fast inference still is.
A Few Things You Should Check Before You Commit
Model rankings move fast, and this space in particular seems to reshuffle every few months. Before locking in a choice for a production system, it’s worth doing a quick sanity check:
Pull up the actual model card on Hugging Face rather than trusting a blog post, including this one. License terms occasionally change between versions of the same model family.
Confirm the license file in the repository actually says Apache 2.0.
Some labs announce open releases that turn out to be gated, restricted, or API-only until weights eventually land.
Test on your own data and your own hardware.
Benchmark numbers vary wildly depending on which harness, prompt set, and attempt count was used, and self-reported scores aren’t always directly comparable to independent ones.
Conclusion
There isn’t a single “best” open source model in 2026, and there probably won’t be next year either. What there is now, more than in previous years, is genuine choice. Qwen gives you licensing peace of mind across a huge range of sizes. Mistral gives you a full spectrum from tiny edge models to a genuine 675B-parameter flagship. Inkling gives you a foundation built specifically for fine-tuning. Apertus gives you language coverage most labs don’t bother with. And none of them will make your legal team nervous.
Frequently Asked Questions
Does Apache 2.0 mean fully open source?
Not quite, at least not in the sense that fully open source usually suggests. Generally, fully open source means the weights, training code, and training data were all publicly released to allow for auditors to re-train and reproduce models from nothing.
Can I fine-tune an Apache 2.0 model and keep my fine-tuned version closed source?
Yes! This is arguably part of the attraction of the Apache 2.0 license. You can update weights or train further on new data without needing to give back the result(s)-unlike copyleft-style licenses, which may, in some situations, compel you to share any derivative work.
Do I need to attribute the original model in my product?
Apache 2.0 still requires you to keep the copyright and license notice intact in Redistribution of the source code, but it doesn’t require any visible attribution (e.g., notice in the GUI of your product). Even so, some sort of note of the base model is often good to include in your documentation for clarity.
Are these models safe for regulated industries (e.g., healthcare, finance)?
The license has removed one barrier on the legal side, but licensing and regulatory compliance are two different things. You still need to worry about privacy, testing for bias, and validating its performance against your use-case-whatever license, that work is on you.
What if the lab changes the license on a future model release?
Labs will and have done this. The safest practice is to pin a particular version of a model and license, and if using its successor, you will need to re-verify the license to ensure it’s suitable for your needs; you cannot assume the newer versions from the lab will also be Apache 2.0 or other permissive licenses.
