If you step into the world of open-source models, you face a long, shifting list: several families, each with many versions and sizes. Memorizing the list is pointless; by the time you finish, a newer version is out. What lasts is the logic of choosing.
This article compares families by their stable traits and then gives criteria that work with any new model. If the concept is new to you, start with open-source AI models: what they are and when to use them.
What "family" means#
Builders usually release a set rather than a single model: sizes from small to large, a base version and an instruction-tuned (Instruct) version tuned for conversation, and sometimes specialized versions for code, images or reasoning. When comparing, first learn the family, then pick the size and version.
Well-known families and general traits#
The names are real, but details change from version to version; check each one on its official page.
| Family | Maker | General trait |
|---|---|---|
| Llama | Meta | Largest ecosystem and tooling; many sizes; its own license |
| Mistral and Mixtral | Mistral AI | Efficient for their size; some models have permissive licenses |
| Qwen | Alibaba | Broad multilingual coverage, many sizes and specialized coding versions |
| Gemma | Relatively small models suited to local use; its own terms of use | |
| DeepSeek | DeepSeek | Focus on reasoning and coding |
| Phi | Microsoft | Small models focused on efficiency at low size |
This table is not a ranking. "Which is better" without "for what task and on what hardware" is an unanswerable question.
Which for what#
Chat and general Q&A#
Instruct versions of the large families such as Llama, Qwen and Mistral are common choices. For languages other than English, multilingual coverage matters more than fame; always test with your own text.
Coding#
Some families have code-specific versions (such as the coding versions of Qwen or DeepSeek). These are usually stronger at code completion and explaining functions. For coding-assistant tools, see AI tools for programming.
Running on a personal computer#
Smaller models from families such as Gemma and Phi, and the compact versions of Llama and Qwen, suit local use, especially in quantized form. The how-to is in running AI on your own computer.
Server and website use#
For a site with a chatbot or internal tool, pick a mid-sized model with good performance and a suitable server; deployment details are in running an open-source model on a server for your site.
Semantic search and RAG#
You do not need a large language model here; dedicated embedding models are small and specialized. We explain them in embeddings and semantic search in plain language.
Five fixed criteria for choosing#
With any new model, ask the same five questions:
- License: is commercial use allowed? Are there conditions or restrictions?
- Size and hardware: does it fit your GPU memory or RAM? Is there a quantized version?
- Language: does it understand and write your language well on your real text?
- Task type: is it general or specialized (code, reasoning, images)? Is there an instruct version?
- Ecosystem: does it have enough runtime tooling, community and documentation?
Also ask about the context window; if you have long documents, the maximum input length matters (the concept is explained in tokens, context window and hallucination).
A simple comparison test#
Instead of trusting general leaderboards, build a test for your own work:
- Collect ten to twenty real samples from your job: customer questions, texts to summarize, code snippets.
- Run them all through two or three models with an identical prompt.
- Compare outputs blind, without knowing which model wrote which.
- Record speed and resource use as well as quality.
The result often shows that a smaller model is enough for your work, or that a famous model drops in quality in your language.
Closing notes#
- Open source is not the same as open weights: some models publish weights but not the training data or code. Judge how much this difference matters for your real needs.
- Security: download models and tools from official sources and do not run unknown files.
- Short shelf life: do not lock today's choice in forever; build a layer that makes swapping models easy.
A few common mistakes when choosing#
- Choosing by name: a famous model is not necessarily right for your work; a test on a few real samples is more reliable than any reputation.
- Forgetting running costs: a big model means more servers and power. Do not compare cost only with a cloud service's price; count maintenance, updates and monitoring too.
- Ignoring quantized versions: sometimes a quantized version of a larger model beats the full version of a smaller one. With a small quality loss, speed and memory improve greatly.
- Ignoring updates: a family released once and no longer supported is a risk for a long-term system.
- Overlooking the cloud alternative: if your volume is low or you have no technical team, a cloud service may be simpler than self-hosting. Decide by need, not just a liking for open source.
Summary#
- Instead of memorizing model lists, learn the families and the selection criteria.
- Llama, Qwen, Mistral, Gemma, DeepSeek and Phi each have their own strengths and licenses; check details on the official page.
- A bigger model is not always better; size must fit your hardware and task.
- Read the license before commercial use.
- Test your own language with real text, not just public leaderboards.
- Build the architecture so that swapping models is possible.
