10 Best Open Source LLMs (November 2026)

The best open-source LLM is the one you can deploy, evaluate, and maintain for the work you actually need. A model that fits a workstation can be more valuable than a higher-scoring model that requires a cluster. Conversely, an organization running demanding coding agents may reasonably accept substantial infrastructure costs for stronger task performance.

We independently evaluated every model in this guide for capability, deployment practicality, licensing, documentation, and suitability for its stated use case. This is an editorial ranking, not a new hands-on benchmark: published performance claims come from the linked model developers and are not directly comparable across different harnesses or settings. Practical accessibility carries substantial weight, which is why Qwen3.8-27B, Gemma 4, and gpt-oss lead the list.

Scope: This guide covers both open-source and open-weight LLMs. Downloadable weights do not necessarily include training data or unrestricted usage rights. Each entry identifies its checkpoint or family and license; do not transfer licensing assumptions from an older version or a different model from the same developer. Reviewed October 14, 2026.

Best Open-Source and Open-Weight LLMs Compared

1. Qwen3.8-27B

Qwen3.8-27B is our first recommendation for developers who want a capable, adaptable model without moving immediately to a large GPU cluster. It combines a dense language model with native image and video understanding, making it useful for coding, document analysis, research assistants, and applications that need to interpret screenshots. Its position reflects that balance of capabilities and deployment practicality, rather than a claim that it wins every benchmark.

The model supports configurable thinking and a native 262,144-token context window, with an extension path to one million tokens. That distinction matters: extended context requires configuration and additional resources, and should not be treated as the default experience on a workstation. For an internal document assistant, start with a modest context and retrieval, then expand only when longer inputs measurably improve answers.

The checkpoint uses Apache 2.0. Quantized versions make local experimentation more approachable, but the language model, vision components, cache, and runtime all consume memory. Choose an implementation that explicitly supports its architecture and multimodal inputs; a successful text-only load does not establish that images, tool calls, or extended context work correctly.

View Qwen3.8-27B Model Card

2. Gemma 4

Gemma 4 is the most useful family here for matching a multimodal application to different hardware budgets. Google offers several sizes, including small effective-parameter models, a 12B model, a 26B mixture-of-experts option, and a dense 31B model. This gives developers a path from constrained devices to workstations without assuming that every user can operate the largest checkpoint.

Capabilities differ within the family. The 31B model accepts text and images, while E2B, E4B, and 12B also support audio input. Smaller variants have 128K context, and the larger configurations offer 256K. For a document or voice application, choose the specific checkpoint by input requirements first; the largest model is not automatically the most suitable when it lacks a required modality.

Gemma 4 uses Apache 2.0, but hardware planning still needs care. The effective parameter counts of E2B and E4B exclude some large embedding components, so those names are not reliable memory estimates. We rank the family highly for deployment choice; readers seeking maximum capability from one fixed workstation should compare the appropriate Gemma variant directly with Qwen on their own documents and prompts.

View Gemma 4 Model Card

3. gpt-oss

OpenAI’s gpt-oss remains a practical starting point for private text reasoning and tool-enabled assistants. The family includes 20b and 120b variants, with the smaller model aimed at more accessible hardware. It earns a high position because the deployment target is clear: users can build a local reasoning system without starting from the infrastructure demands of a trillion-parameter model.

The official release uses MXFP4 quantization for its expert weights. OpenAI documents operation within 16GB of memory for 20b and on an 80GB GPU for 120b; those figures should not be read as guarantees for every context length, runtime, or number of simultaneous users. Reasoning effort can be adjusted, and the model supports structured outputs and tool calls when the application supplies the necessary execution layer.

Both models use Apache 2.0 and require the correct Harmony formatting. They are text-only, so visual document workflows need another component. For a coding assistant, validate tool schemas and error recovery before granting write access. The strongest reason to choose gpt-oss is controllable, comparatively accessible text inference; users prioritizing native vision should start with another entry.

View gpt-oss Model Card

4. DeepSeek V4

DeepSeek V4 is a strong choice for organizations that can support large-scale inference and want broad reasoning and coding capability. The important update is the official Pro-0813 release, which supersedes the earlier Pro preview. An evaluation should identify that exact checkpoint rather than treating every endpoint labeled V4 as equivalent, particularly when comparing results or debugging changes in agent behavior.

The family spans Pro with 1.6 trillion total parameters and 49 billion activated per token, and Flash with 284 billion total and 13 billion activated. Its architecture supports a million-token context, while the official Pro release adds a speculative decoding module. These design choices target efficiency at considerable scale; activated parameters describe computation and do not eliminate the need to store the remaining expert weights.

The release is MIT-licensed. We place it below the workstation-oriented leaders because deployment complexity sharply narrows its audience, not because smaller models universally outperform it. A team building a central inference service should compare Pro and Flash on completed-task cost, concurrency, and tool reliability. A solo developer looking for a quick local assistant should begin with a smaller checkpoint elsewhere in this guide.

View DeepSeek V4 Model Card

5. GLM-5.3

GLM-5.3 is Z.ai’s updated open-weight option for difficult software engineering and extended agent tasks. It uses the same base model as GLM-5.2, with improvements coming from post-training. The developer reports substantial gains across coding and agent benchmarks, making this the relevant version to assess instead of simply retaining the previous generation’s position and description.

Its appeal is sustained work across tools, files, and intermediate results. However, a model’s published agent score also depends on the harness, reasoning budget, context management, and time allowed. For a repository assistant, evaluation should track whether it completes the requested change, introduces regressions, and uses tools correctly. A benchmark headline alone cannot establish those outcomes inside a different development environment.

The licensing distinction is material: GLM-5.3 uses a custom license, not the MIT label previously associated with this article’s GLM-5.2 entry. The license includes an additional review condition for certain very large model-as-a-service businesses. Its substantial checkpoint also requires server-class planning. GLM-5.3 belongs on an enterprise coding shortlist, but it is a poor default for readers who want uncomplicated laptop deployment.

View GLM-5.3 Model Card

6. Kimi K3

Kimi K3 is the specialist choice for organizations combining visual understanding with long-running reasoning and tool use. Moonshot’s model has 2.8 trillion total parameters, approximately 104 billion activated per token, native vision, and a one-million-token context window. It is relevant when an assistant must work across code, screenshots, documents, and extended interaction histories within the same system.

The integration details are particularly important. Kimi K3 keeps thinking enabled and expects complete assistant messages, including reasoning and tool-call information, to be preserved across turns. An application that stores only the final answer can therefore mishandle the intended conversation format. Before comparing it with another model, confirm that the serving layer and agent framework preserve the required history correctly.

Its custom license and very large checkpoint make this an infrastructure decision as much as a model choice. Native quantization helps serving efficiency but does not turn it into a normal workstation model. We recommend Kimi K3 for teams that can justify the operational expense through demanding multimodal workflows; ordinary text summarization or small document collections rarely require this level of scale.

View Kimi K3 Model Card

7. Mistral Small 4

Mistral Small 4 combines general instruction following, reasoning, coding, and image understanding in one model. This makes it attractive for a business application that needs several capabilities behind a consistent interface rather than maintaining separate specialist models for every request. Its position reflects that operational versatility, especially for teams already comfortable managing a substantial inference service.

Despite the Small name, it contains 119 billion total parameters, with 6.5 billion activated per token. It supports a 256K context window and configurable reasoning effort, allowing a service to use shorter responses for routine questions and more deliberation for difficult tasks. The mixture-of-experts architecture reduces active computation, but the full set of weights still determines much of the storage and memory burden.

The checkpoint uses Apache 2.0. Official quantized and speculative-decoding options provide optimization paths, although their benefits depend on hardware and runtime support. For a support assistant that reads screenshots and produces structured actions, test image quality, schema adherence, and response time together. Choose it when consolidating several capabilities simplifies operations; do not assume its name implies the footprint of an 8B laptop model.

View Mistral Small 4 Model Card

8. Devstral Small 2

Devstral Small 2 is a focused alternative for developers who primarily want a model to explore repositories, edit files, and operate inside a software engineering agent. Its 24-billion-parameter size gives it a more approachable deployment profile than the large coding systems above. It remains useful as a specialist even when newer general-purpose models deserve a place in the same evaluation.

Mistral documents a 256K context window, image understanding, and integration with its Vibe coding environment. The model’s value comes from how well it handles a complete edit-and-test workflow, rather than whether it can produce an impressive isolated code snippet. Assess it on your repository structure, programming languages, dependency constraints, and test suite, using the same tools and permissions as competing models.

The release uses Apache 2.0. Mistral identifies consumer GPU and 32GB Mac deployment possibilities, but precision, context, and runtime overhead affect what actually fits. Start with shorter sessions and a compatible quantization before attempting huge repositories in one prompt. We favor it for a dedicated coding workstation; teams needing broad research, voice, or general multimodal assistance should compare its narrower focus with the higher-ranked generalists.

View Devstral Small 2 Model Card

9. Nemotron 3 Nano

NVIDIA’s Nemotron 3 Nano is an interesting option for developers optimizing the efficiency of text-based agents. It combines Mamba components, attention, and mixture-of-experts layers, with 30 billion total parameters and about 3.5 billion active per token. The reason to evaluate it is the architecture’s operational fit, rather than the assumption that the Nano name means it can run on any device.

The model supports reasoning and non-reasoning behavior through its chat template. That gives an application a way to reserve longer deliberation for difficult requests while seeking faster responses for simpler ones. Its hybrid architecture also makes runtime support an essential selection criterion: verify the exact engine, quantization format, and hardware combination instead of assuming every standard transformer optimization applies.

The release uses the NVIDIA Nemotron Open Model License. It is a worthwhile specialist candidate for teams building a repeatable inference benchmark and willing to tune their deployment. Compare time to a correct answer, memory use, and concurrent request behavior alongside output quality. Readers who primarily want a ready-to-use visual assistant will find the multimodal choices earlier in this ranking more directly suited to that goal.

View Nemotron 3 Nano Model Card

10. Olmo 3.1

Ai2’s Olmo 3.1 deserves a place because openness is more than a download button. The 32B Instruct model sits within an ecosystem that exposes training datasets, code, intermediate checkpoints, and methodology. For researchers examining how training decisions affect behavior, those resources can be more valuable than a higher score from a model whose development process is largely inaccessible.

The family provides Instruct and Think variants, and its documentation links the pre-training and post-training stages. That makes it easier to investigate adaptation choices and compare stages of model development. Start with an instruction-tuned checkpoint for an assistant; a base checkpoint serves a different purpose and should not be judged as though it were already optimized for conversational use.

Olmo 3.1 uses Apache 2.0 and is primarily an English text model. We rank it as the transparency specialist, not as a claim that it leads frontier capability. A research group, educator, or team studying model adaptation has a strong reason to choose it. A production buyer seeking native vision, maximum multilingual breadth, or the strongest turnkey coding agent should evaluate the alternatives above first.

View Olmo 3.1 Model Card

How Much Memory Do You Need?

Begin with the actual checkpoint size and the runtime’s documented requirements. A rough weight-only estimate is parameter count multiplied by bits per weight, divided by eight. A 30B model at four bits is approximately 15GB before quantization metadata, unquantized components, context cache, temporary buffers, and the operating system. This is an arithmetic lower bound, not a promise that it fits a 16GB machine.

For mixture-of-experts models, use total parameters to estimate weight storage. Activated parameters help explain computation per token; they do not mean the other experts disappear. CPU offloading can reduce GPU memory requirements but may substantially reduce speed. Unified memory on a Mac is shared with the system, so it should not be treated as entirely available to the model.

• Constrained personal machines: Start with a smaller Gemma variant, or evaluate gpt-oss-20b using a supported configuration. Leave headroom and keep initial context modest.
• Workstations with more memory: Compare quantized Qwen3.8-27B, appropriate Gemma variants, and Devstral Small 2. Verify image support separately from text inference.
• Servers and clusters: Consider DeepSeek V4, GLM-5.3, Kimi K3, or larger configurations when task value justifies serving cost and operational complexity.

A model’s maximum context window is also not a recommended everyday setting. Longer inputs increase memory and processing demands, while concurrent users multiply resource requirements. For installation choices and the distinction between models, runtimes, and interfaces, see our guide to tools for running LLMs locally.

Open Source, Open Weights, and Private Deployment

Weight access gives you control over where inference runs, but it does not automatically provide the full training recipe or make every use permissible. Apache 2.0 and MIT entries should still be checked at the exact checkpoint. GLM-5.3, Kimi K3, and Nemotron use their own model licenses. Olmo is especially relevant when access to the development process matters as much as access to the final weights.

Self-hosting can keep prompts inside your infrastructure, provided the complete application is configured that way. Cloud embeddings, remote search, logging services, and agent tools can still send data elsewhere. Evaluate the complete workflow, and measure incorrect answers and failed actions alongside latency. For tools that modify files or interact with business systems, use bounded permissions and an approval step where the action warrants one.

Which Open LLM Should You Choose?

For a practical first comparison, start with Qwen3.8-27B for general multimodal applications, Gemma 4 for a choice of local model sizes, and gpt-oss for accessible text reasoning. These offer useful entry points before committing to a central inference cluster.

For demanding server-scale work, compare DeepSeek V4 for broad reasoning and coding, GLM-5.3 for extended software agents, and Kimi K3 for multimodal workflows. Mistral Small 4 is worth evaluating when a single model must handle several business tasks with configurable reasoning.

The specialists answer different needs: Devstral Small 2 for a focused coding workstation, Nemotron 3 Nano for efficiency-oriented text agents, and Olmo 3.1 for transparent research and adaptation. Choose two or three that fit your hardware and license requirements, then evaluate them on the same representative tasks before selecting a deployment.