Best Ollama Models 2026: 15 Ranked (Coding, Reasoning, Chat)

The best Ollama models in 2026 are Qwen3.6-27B for overall quality on a single GPU (68.9% SWE-bench Verified, ~17GB VRAM), qwen3-coder:30b for coding on 24GB cards (256K context at small-model speed), and gpt-oss:20b as the pick for 16GB cards. DeepSeek R1 is still the reasoning model to beat, and for 8GB setups Llama 3.1 8B remains the most versatile option at ~5GB VRAM.

Why Does Ollama Model Choice Matter So Much?

Picking the right Ollama model is the single biggest factor in your local AI experience. A well-matched model runs fast, produces quality output, and fits your hardware. A poor choice gives you either slow responses or disappointing quality.

The Ollama library lists hundreds of models, but most users only need to know about 10-15 that consistently outperform the rest. This guide ranks those top models by task — coding, chat, reasoning, creative writing, and RAG — with VRAM requirements and the throughput arithmetic you can apply to your own card, so you can pick the right one immediately. If you'd rather work through the whole Ollama workflow in order — install, model library, Modelfiles, GPU offload, serving — the Ollama Mastery course covers it end to end; the first chapter is free with an account.

All models listed here are free, open-weight, and run entirely on your hardware. No API keys, no subscriptions, no data leaving your machine.

---

Top 15 Ollama Models Ranked

Overall Ranking (updated August 2026)

Benchmark sources: every HumanEval, MMLU and SWE-bench figure in this table comes from the vendor's own model card or release announcement (Meta, Alibaba, DeepSeek, Google, Microsoft, OpenAI) — check the Hugging Face model card for the exact evaluation harness before comparing across families, because the prompt formats differ. The 2026-generation models (Qwen3.6, Qwen3-Coder, gpt-oss, Gemma 4) publish SWE-bench and agentic scores rather than classic HumanEval/MMLU, so those cells show a dash — their signature numbers are in the Best For column and the sections below. There is no tokens-per-second column here on purpose: nobody's throughput is portable to your machine. Work out your own ceiling instead — it is one division.

What moved in this update: Qwen3.6-27B takes #1 from Llama 3.3 70B because it needs less than half the VRAM and beats it on agentic coding, which makes it the better recommendation on the hardware most readers actually own. Qwen3-Coder 30B and gpt-oss:20b enter the top tier, and Google's Gemma 4 12B Unified replaces Gemma 2 27B. Mistral 7B, Mistral Small 24B, and Llama 3.2 3B drop out to make room — all three still work fine, they are just no longer top-15 picks.

---

What Are the Newest Ollama Models Worth Running in 2026?

The pace of new local models has not slowed. Since this guide first published, several releases have shifted what is worth pulling — especially the new wave of Mixture-of-Experts (MoE) models that activate only a few billion parameters per token, so they punch far above their size-on-disk while staying fast.

What changed and what to pull:

• The dense surprise: Qwen3.6-27B. Alibaba's April 2026 dense 27B beats its own 397B MoE flagship on agentic coding (68.9% vs 65.4% SWE-bench Verified) while fitting a single RTX 4090/5090 at ~17GB Q4. If you have one good GPU and want one model for coding plus general work, this is the current default — full breakdown in our Qwen3.6-27B review.
• MoE is the headline. qwen3-coder:30b (the "30B-A3B" build) carries 30B total parameters but activates only ~3B per token, so it generates at roughly 7B-class speed while reasoning closer to a 30B dense model. It is the new sweet spot for agentic coding on a 24GB GPU, and natively handles 256K tokens of context for repository-scale work.
• OpenAI's gpt-oss landed on Ollama. gpt-oss:20b runs on a 16GB card and is a genuine alternative to Qwen 2.5 32B for reasoning + agentic tasks; gpt-oss:120b is for workstation-class setups (single 80GB GPU or a 64GB+ Mac with offload).
• Devstral is purpose-built for the read-edit-coordinate loop across multiple files, making it a better day-to-day agentic coder than a general 24B chat model. If your VRAM tops out at 24GB, run the largest coding-specialised model you can fit rather than a general one — the same principle our model size picker tool applies automatically.

Dense Qwen 2.5 Coder 32B and Llama 3.3 70B from the table above remain excellent and very widely deployed; the MoE arrivals don't retire them, they add a faster middle lane. For a deeper install-and-tune walkthrough of any of these, see the complete Ollama guide. And if your current GPU can't fit the model you want, the local AI hardware guide shows exactly what each budget tier unlocks.

Not sure which model your card can actually run? The picks are broken out by VRAM tier — 8GB, 12GB, 16GB, and 24GB — each with the Q4 footprint you need to fit. And the standout new small-footprint pick is Google's Gemma 4, which runs offline from a Raspberry Pi up to a single GPU.

---

Best Ollama Model for Coding

On a 24GB GPU, pull qwen3-coder:30b — it is the best Ollama coding model right now (~19GB at Q4, 256K native context, MoE so it generates at small-model speed). On an 8GB card, use Qwen 2.5 Coder 7B, and for editor autocomplete use Qwen 2.5 Coder 1.5B. If you want a single model for coding plus general work, Qwen3.6-27B (68.9% SWE-bench Verified, ~17GB) is the stronger all-rounder.

Why Qwen owns local coding: The Qwen 2.5 Coder series was trained on 5.5 trillion tokens of code data spanning 92 programming languages — the 32B scores 92.7% on HumanEval and the 7B at 88.4% outperforms models 4x its size. The newer Qwen3 generation adds MoE on top: qwen3-coder:30b activates only ~3B of its 30B parameters per token, so you get 30B-class code reasoning at roughly 7B-class generation speed, plus a 256K context that fits whole repositories.

Best setup for AI-assisted coding:

• Use Qwen 2.5 Coder 1.5B for fast autocomplete in Continue.dev or Cursor
• Use qwen3-coder:30b (24GB) or Qwen 2.5 Coder 7B (8GB) for chat, refactoring, and code review
• See our best local AI coding models guide, or the coding picks by VRAM tier: 8GB and 16GB

---

Best Models by Task

Best for General Chat

Chat models handle conversation, Q&A, summarization, and everyday tasks.

Llama 3.3 70B is the best local chat model if you have the hardware. It replaced Llama 3.1 70B with better instruction following and reduced hallucination. For most users, Qwen 2.5 32B hits the sweet spot of quality and resource requirements — though if you only have one 24GB card, Qwen3.6-27B from the ranking above doubles as a strong chat model, and many single-GPU users now run it for everything.

Phi-4 Mini is remarkable at 3.8B parameters — it matches Llama 3.1 8B on MMLU while using 40% less VRAM.

Best for Reasoning and Math

Reasoning models excel at logic puzzles, math, analysis, and multi-step problem solving.

DeepSeek R1 uses chain-of-thought reasoning — you can see the model's thinking process before it gives the final answer. This makes it noticeably better at math, logic, and complex analysis than standard instruct models. DeepSeek publishes MATH-500 and AIME scores for each distilled size on the DeepSeek model cards; we are deliberately not restating them here, because the distilled Ollama builds are quantized and the published numbers are for the full-precision weights. The 14B version is the best value: strong reasoning at just 9GB VRAM.

One practical cost the benchmarks hide: reasoning models emit hundreds of "thinking" tokens before the answer. At the same tokens-per-second, an R1 reply takes several times longer to arrive than a Qwen 2.5 reply. Budget for that before you make R1 your default chat model.

Best for RAG (Document Chat)

RAG models work alongside embedding models to answer questions from your documents.

For the language model (answers questions):

For the embedding model (indexes documents):

nomic-embed-text is the standard choice for RAG with Ollama — it is the most-pulled embedding model in the library and works with Open WebUI, AnythingLLM, and most RAG frameworks. Our best Ollama embedding models for RAG page lines it up against mxbai, bge-m3 and the rest using each model's published MTEB retrieval scores, and the RAG local setup guide has the complete walkthrough.

Best for Vision (Image Understanding)

Vision models can describe images, read text from screenshots (OCR), analyze charts, and answer questions about photos. The 11B version handles most tasks well at 8GB VRAM, though the Qwen and MiniCPM families have since overtaken it — see our comparison of the best local vision models for how Qwen3-VL, MiniCPM-V, and Moondream stack up.

Uncensored and Low-Refusal Models

The most popular low-refusal models on Ollama are the Dolphin fine-tunes: dolphin3 (Llama 3.1 8B base), dolphin-mistral (7B), and dolphin-mixtral (8x7B MoE). They are community retrains that strip most of the refusal behavior out of the base model, so they will answer questions the stock models decline — useful for fiction writers working with dark themes, security researchers, and anyone tired of refusals on harmless prompts.

Two honest caveats. First, the trade-off is real: the Dolphin models ride on older bases (Llama 3.1, Mistral 7B, Mixtral), so raw capability sits a clear generation behind Qwen3.6 or Llama 3.3 — you give up quality for fewer refusals. Second, "uncensored" removes the guardrails, not your responsibility: these models will confidently produce wrong or harmful text with no pushback, and what you generate and publish is on you. Run them for the use cases that need them, not as your daily driver.

Install with ollama pull dolphin3, ollama pull dolphin-mistral, or ollama pull dolphin-mixtral:8x7b. We cover the Mixtral variant in more depth in our Dolphin Mixtral 8x7B review, and if you are after the image-generation side of this topic, see uncensored local image generation. For the full text-model guide — abliterated builds, VRAM needs per card, and honest quality trade-offs — see Best Uncensored Local LLMs.

---

The Ollama Library at a Glance

Ollama can run any model in its public library — hundreds of open-weight chat, coding, reasoning, vision, and embedding models — plus any GGUF file you import yourself. The top-15 above covers our ranked picks; the table below is the wider map of what people actually pull, with the sizes on offer and the VRAM you need at the default Q4 quantization. For exact Q4/Q5/FP16 file sizes and minimum VRAM per model beyond this summary, see the full Ollama model RAM & VRAM table.

VRAM figures follow the same rule of thumb as the rest of this guide (~0.6GB per billion parameters at Q4, plus overhead) and refer to the bolded size where a family ships several. Ollama also runs any custom GGUF via a Modelfile FROM line — the complete Ollama guide shows how. To size a specific model against your card, use the VRAM calculator.

---

Models by Hardware Budget

8GB RAM / No Dedicated GPU

You're limited to 3B-4B parameter models on CPU inference, and system RAM is the bottleneck. Dual-channel DDR5-5600 tops out near 90 GB/s and DDR4-3200 near 51 GB/s, so a 2GB Q4 3B model has an arithmetic ceiling of about 45 t/s and 25 t/s respectively — and you will land a long way below that, because the CPU also has to do the matrix arithmetic a GPU does in parallel. Anything above 4B on this tier is a batch job, not a chat.

# Best picks for 8GB RAM
ollama pull llama3.2          # 3B - best general quality
ollama pull phi4-mini          # 3.8B - surprisingly capable
ollama pull gemma2:2b          # 2B - fastest, basic tasks

16GB RAM / 8GB VRAM (RTX 3060, M1/M2 16GB)

The sweet spot for most users. 7B-8B models run at full GPU speed.

# Best picks for 16GB / 8GB VRAM
ollama pull llama3.1:8b        # Best general-purpose 8B
ollama pull qwen2.5-coder:7b   # Best coding 7B
ollama pull deepseek-r1:7b     # Reasoning with chain-of-thought
ollama pull nomic-embed-text   # Embeddings for RAG

16GB VRAM (RTX 4080, RTX 4060 Ti 16GB)

The new MoE wave made 16GB genuinely useful — 20B-class quality without a flagship card.

# Best picks for 16GB VRAM
ollama pull gpt-oss:20b        # OpenAI open-weight MoE — the 16GB headliner
ollama pull qwen3:14b          # Best dense 14B all-rounder
ollama pull gemma4:12b         # Text + image, 256K context
ollama pull deepseek-r1:14b    # Reasoning with chain-of-thought

24GB VRAM (RTX 4090, M3 Pro 36GB)

Access to the 27B-32B class — a massive quality jump over 8B.

# Best picks for 24GB VRAM
ollama pull qwen3.6:27b         # Best overall — coding + general (68.9% SWE-bench)
ollama pull qwen3-coder:30b     # Agentic coding, 256K context, MoE speed
ollama pull qwen2.5-coder:32b   # Strongest dense coder (92.7% HumanEval)
ollama pull deepseek-r1:32b     # Best reasoning model

48GB+ VRAM (RTX 5090 32GB + offload, 2x GPUs, M4 Max 64GB)

Run 70B models — comparable to GPT-4 turbo.

# Best picks for 48GB+
ollama pull llama3.3:70b       # Best overall local model
ollama pull qwen2.5:72b        # Excellent multilingual

---

How Fast Will a Model Run on My GPU?

Token generation is a memory-bandwidth problem, not a compute problem. To emit one token, the hardware has to read every weight in the model exactly once — so the hard ceiling is one division:

tokens/sec ceiling = memory bandwidth (GB/s) / model file size (GB)

Take the bandwidth from your card's spec page and the GGUF size from ollama list. What you get is an arithmetic upper bound, not a prediction — real output lands below it, because attention over the KV cache, sampling, and framework overhead all cost time the formula ignores. The gap is small for large models (where reading weights dominates) and large for tiny models (where per-token overhead dominates). Use it to compare options and to sanity-check any benchmark you read: a number above the ceiling is impossible.

Vendor-published bandwidth for common targets:

Apply the formula and you get this ceiling table. Every cell is bandwidth divided by file size — you can reproduce all of it with a calculator:

Three things worth taking from it:

1. "Won't fit" matters far more than the speed column. The moment a model spills out of VRAM, Ollama offloads layers to system RAM and the effective bandwidth for those layers collapses to the DDR figure — roughly an order of magnitude lower. That is why a model that just fits feels dramatically faster than one that nearly fits, and why leaving 2-3GB of headroom is the single highest-value tuning decision you make.
2. Quantization moves the ceiling linearly. Dropping Llama 3.1 8B from Q4_K_M (4.7GB) to Q3_K_S (~3.7GB) shrinks the file about 21% and raises the ceiling by the same 21%. That is the entire mechanism — there is no magic in a smaller quant beyond fewer bytes to read.
3. MoE models break the intuition in your favour. qwen3-coder:30b holds 30B parameters but activates ~3B per token, so it reads far less than its 19GB footprint per token and generates closer to a 7B-class rate. It still needs the full 19GB resident.

For a specific card and model, the VRAM calculator does the same arithmetic for you, and GPU memory bandwidth for local LLMs works through why bandwidth rather than TFLOPS is the binding constraint. If a model is running far below its ceiling, local LLM slow? here's the fix covers the usual causes.

---

How to Pick the Right Model

Decision Flowchart

Step 1: What's your VRAM?

• Under 4GB → Gemma 2 2B or Llama 3.2 1B
• 4-8GB → 7B-8B models
• 8-16GB → 14B-24B models
• 16-24GB → 32B models
• 24GB+ → 70B models

Step 2: What's your primary use case?

• General chat → Qwen3.6-27B on a 24GB card, else Llama 3.1/3.3 or Qwen 2.5 (largest that fits)
• Coding → qwen3-coder:30b on 24GB, else Qwen 2.5 Coder (largest that fits)
• Reasoning/math → DeepSeek R1 (largest that fits)
• Fast autocomplete → Qwen 2.5 Coder 1.5B
• Document Q&A → Llama 3.1 8B + nomic-embed-text

Step 3: Speed vs Quality?

• Need fast responses → Pick one size down from your maximum
• Need best quality → Pick the largest that fits your VRAM
• Running multiple models → Leave 4-6GB headroom for the OS and second model

Common Mistakes to Avoid

1. Running a model that barely fits — If your model uses 23.5GB of 24GB VRAM, you'll get swapping and slowdowns. Leave 2-3GB headroom.
2. Using general models for coding — Qwen 2.5 Coder 7B massively outperforms Llama 3.1 8B on code tasks despite being smaller. Use specialized models.
3. Ignoring quantization — Always use Q4_K_M (Ollama default). Full precision wastes VRAM with negligible quality gain.
4. Chasing parameter count — A well-trained 32B model (Qwen 2.5) often outperforms a mediocre 70B model. Quality of training data matters more than size alone.

---

Model Management Tips

Check Installed Models

ollama list
# NAME                     ID            SIZE     MODIFIED
# llama3.1:8b              365c0bd3c000  4.7 GB   2 days ago
# qwen2.5-coder:7b         12345abc      4.4 GB   1 day ago

Free Up Disk Space

# Remove models you no longer use
ollama rm codellama:7b
ollama rm mistral:7b

# Models are stored in:
# macOS: ~/.ollama/models
# Linux: /usr/share/ollama/.ollama/models
# Windows: C:\Users\<user>\.ollama\models

Pull Specific Quantizations

# Default (Q4_K_M) — best balance
ollama pull llama3.1:8b

# Higher quality (Q5_K_M) — 10-15% more VRAM
ollama pull llama3.1:8b-instruct-q5_K_M

# Smallest (Q2_K) — 30% less VRAM, noticeable quality loss
ollama pull llama3.1:8b-instruct-q2_K

Set Context Window Size

# In Ollama chat, increase context window:
/set parameter num_ctx 8192

# Or create a Modelfile for persistent settings:
# Create a file called Modelfile:
# FROM llama3.1:8b
# PARAMETER num_ctx 8192
# PARAMETER temperature 0.7

# Then: ollama create my-llama -f Modelfile

---

Does the Model Runner Change Which Model Is "Best"?

A question that comes up constantly: do these rankings change if you run models through LM Studio or Msty instead of Ollama? The short answer is no — the model weights are identical. A Q4_K_M GGUF of Qwen 2.5 Coder 32B produces the same quality whether Ollama, LM Studio, or Msty loads it. What differs is the experience around the model.

• Ollama is the lightest, most scriptable runner — a single ollama pull / ollama run workflow and a built-in API that every tool in this guide targets. Best if you want models available to other apps.
• LM Studio adds a polished GUI, a model browser, and easy quantization switching — friendlier if you prefer clicking over the terminal.
• Msty layers chat features (split chats, knowledge stacks, web search) on top.

If you're deciding which runner to standardise on before you commit to a model library, our Msty vs Ollama vs LM Studio comparison breaks down the trade-offs in detail. The practical takeaway: pick your models from this guide first, then pick the runner that matches how you like to work — they all read the same GGUF files.

One real-world caveat: VRAM headroom and quantization defaults can differ slightly between runners, which nudges the largest model you can comfortably load. If you're on a tight 8GB or 12GB budget, our best local AI models for 8GB RAM guide lists the picks that stay fast regardless of which runner you choose.

---

FAQ

What is the best overall Ollama model right now?

For most people with one good GPU, Qwen3.6-27B — a dense 27B that Alibaba reports at 68.9% on SWE-bench Verified, beating its own 397B MoE, and that fits a 24GB card at roughly 17GB with Q4 quantization. Install it with ollama pull qwen3.6:27b. With 48GB+ of VRAM or a 64GB Mac, Llama 3.3 70B is still the strongest dense generalist. On 8GB, Llama 3.1 8B remains the most versatile all-rounder.

What is the best Ollama model for coding?

On a 24GB GPU, qwen3-coder:30b — a 30B MoE (~3B active per token) with a 256K native context that generates at small-model speed and uses about 19GB at Q4. If you want one model for coding and general work, Qwen3.6-27B is the better all-rounder. Qwen 2.5 Coder 32B is still the strongest dense coder at Alibaba's published 92.7% HumanEval. Smaller setups: Qwen 2.5 Coder 7B on 8GB, Qwen 2.5 Coder 1.5B for autocomplete at 2GB.

How much VRAM do I need for Ollama models?

Multiply the parameter count in billions by roughly 0.6 for Q4_K_M, then add 1-2GB for the KV cache and context. A 7B needs ~5GB, a 13B ~8GB, a 32B ~20GB, a 70B ~40GB. Apple Silicon draws on unified memory, so a 32GB M2 Pro can hold a 32B. NVIDIA cards need it in dedicated VRAM: RTX 3060 12GB handles up to 13B, RTX 4090 24GB handles 32B, RTX 5090 32GB handles a 70B at low quant. The VRAM calculator does the exact sum.

What Ollama models work on 8GB RAM?

With 8GB of total system RAM and no GPU: Llama 3.2 3B, Phi-4 Mini 3.8B, Gemma 2 2B and Qwen 2.5 Coder 1.5B all run. Llama 3.1 8B technically fits but leaves nothing for context. With 8GB of VRAM (an RTX 3060, say): Llama 3.1 8B, Mistral 7B and Qwen 2.5 7B all run at full GPU speed. The 8GB model guide has the full list.

How do I install a model in Ollama?

ollama pull model-name, then ollama run model-name to chat. ollama list shows what is installed and how big each one is; ollama rm model-name deletes one. Models download once and cache locally — sizes run from about 1.5GB for a 3B to 40GB for a 70B.

Should I use quantized or full-precision models?

Quantized, effectively always. Ollama defaults to Q4_K_M, which roughly halves the bytes versus FP16 for a quality difference most people cannot detect in normal use. Running FP16 locally doubles your VRAM requirement to buy back very little. If you have headroom and want the last few percent, Q5_K_M or Q6_K cost 10-25% more memory.

Can I run multiple Ollama models at once?

Yes. Ollama keeps recently used models resident and serves several concurrently, but each one holds its own VRAM while loaded. With 24GB you could keep a 7B and a 13B up together. Idle models unload after five minutes by default; change that with the OLLAMA_KEEP_ALIVE environment variable.

What is the fastest Ollama model?

The smallest one that still does your job — see the ceiling arithmetic above. Because speed is bounded by how fast the weights can be read, a 1GB Q4 1.5B model has roughly five times the ceiling of a 4.7GB 8B on the same card. Llama 3.2 3B is the best speed-to-quality trade-off in practice; Qwen 2.5 Coder 1.5B is the usual autocomplete pick.

---

Key Takeaways

1. Qwen3.6-27B is the best single-GPU model — 68.9% SWE-bench Verified at ~17GB
2. qwen3-coder:30b is the best coding pick for 24GB cards; Qwen 2.5 Coder 32B is still the dense HumanEval leader (92.7%)
3. Llama 3.3 70B is the best overall model if you have 48GB+ VRAM/RAM
4. DeepSeek R1 is the best reasoning model with visible chain-of-thought
5. Phi-4 Mini 3.8B punches far above its weight for small hardware
6. Always use Q4_K_M quantization (Ollama default) — best quality-per-VRAM
7. Match model to task — specialized models (Coder, R1) beat general models on their domains
8. nomic-embed-text is the go-to embedding model for RAG

---

Next Steps

1. Set up Open WebUI for a ChatGPT-like interface with your models
2. Find models for 8GB RAM if you're on limited hardware
3. Set up Continue.dev for AI coding with Ollama
4. Compare Jan vs LM Studio vs Ollama for model management
5. Check VRAM requirements for detailed GPU sizing
6. Run GPT-OSS locally — OpenAI's first open-source model on Ollama
7. Run Llama 4 Scout locally — Meta's 109B MoE with 10M token context
8. Try Qwen3-Coder — Alibaba's best coding model (70.6% SWE-bench, Alibaba's published figure)
9. RTX 5090 vs 5080 for local AI — which GPU to buy for running models
10. LMArena leaderboard explained — how AI models are ranked by 6M+ votes

---

The Ollama model ecosystem moves fast. This ranking is reviewed against the library and each vendor's published benchmarks as new weights land — last reviewed August 2026. Every throughput figure on this page is arithmetic you can reproduce, not a stopwatch reading; where a number comes from a vendor, it says so.