Best Ollama Models (Nov 2026): 15 Ranked + Picks by Category

The best Ollama model on one 24GB GPU in November 2026 is qwen3.8:27b (18GB download, dense 27B, text + image, 262K context). On a 16GB card pull gpt-oss:20b (14GB) or gemma4:26b (16–19GB MoE with 3.8B active parameters); on 8GB of VRAM pull gemma4:e4b (6.6GB, text + image + audio) or llama3.1:8b (4.9GB, still the most-pulled model in the library); on a CPU-only laptop pull gemma4:e2b (4.6GB) or llama3.2 (2.0GB). For coding on 24GB use qwen3-coder:30b; for reasoning on mid-range cards use deepseek-r1:14b; for embeddings use nomic-embed-text or the newer embeddinggemma-2. Every tag on this page was checked against the Ollama library on 2 November 2026.

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 now sorts itself by capability — Tools, Thinking, Vision, Embedding, Decision — and by where the model runs, Local or Cloud. Those filters are exactly how people search for Ollama models now, so this guide ranks the top 15 overall and names the best pick in each library category, with the exact ollama pull tag and the download size the library shows for it. 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 — except the cloud-only tags in the category section, which Ollama hosts for you and which never download. No API keys for the local ones, no subscriptions, no data leaving your machine.

---

Top 15 Ollama Models Ranked

Overall Ranking (updated 2 November 2026)

Where this table shows a score, it is the vendor's own figure as published on the page cited in this file's header: Google's Gemma 4 table on the Ollama model page, Alibaba's Qwen3.8-27B model card on Hugging Face (SWE-bench Pro was run with the Claude Code harness, so it is not comparable to SWE-bench Verified figures), and Meta's Muse Glimmer comparison table. Rows showing a dash have no vendor number on the model page that survives quantization honestly, so none is printed. There is no tokens-per-second column on purpose: nobody's throughput is portable to your machine. Work out your own ceiling instead — it is one division — and the only measured figures on this site are in the table under that heading.

What moved in this update (2 November 2026): qwen3.8:27b takes #1 from Qwen3.6-27B — same 18GB footprint, adds native image and video input and a 262,144-token context. Google's Gemma 4 family enters at #2, #3, #10 and #13 (the library now lists it at 28.3M pulls, updated two weeks ago), and Meta's muse-glimmer:30b enters at #4. Qwen 2.5 Coder 32B, Qwen 2.5 32B, Phi-4 Mini, Qwen 2.5 Coder 1.5B and Llama 3.2 Vision drop out of the fifteen; all still work and still appear in the task tables below.

---

Best Ollama Models by Category (Cloud, Embedding, Vision, Tools, Thinking)

The library's own filters are the fastest way to answer "which Ollama model?" — so here is the best pick per filter, with the tag and size as the library listed them on 2 November 2026. Where a category has an obvious small-card alternative, it is in the last column.

Three notes on the categories:

• Cloud tags never download. gemma4:cloud, gpt-oss:120b-cloud, deepseek-v4.1-flash:cloud and glm-5.3:cloud run on Ollama's servers; the cloud docs say "Cloud models do not need to be downloaded" and that you sign in during setup to use them. The library marks them with a usage tier instead of a size, and you can switch cloud off entirely with OLLAMA_NO_CLOUD=1. They are listed here because the library lists them; everything else on this page is local.
• Thinking is a per-request switch. Qwen3, DeepSeek R1, gpt-oss and Gemma 4 all expose it; gpt-oss takes a level string (low, medium, high, default medium) through the API's think field. Reasoning tokens cost time — see the reasoning section.
• Vision means image input. Ollama's image generation models (x/z-image-turbo, x/flux2-klein) still sit in the library but the runner support was removed in v0.32.6 — Ollama image generation: what actually works now has the current state.

---

What Are the Newest Ollama Models Worth Running in 2026?

The pace of new local models has not slowed. The library's "newest" sort on 2 November 2026 is dominated by Mixture-of-Experts (MoE) models that activate only a few billion parameters per token, multimodal models that take images and audio, and a new wave of tiny "decision" models for routing and classification.

What changed and what to pull:

• Qwen3.8-27B is the new single-GPU default. The Hugging Face card calls it "a compact, deployment-friendly dense model" with a vision encoder, 262,144-token native context and an Apache 2.0 licence; the Ollama 27b tag is an 18GB Q4_K_M download — the same footprint as Qwen3.6-27B, so a like-for-like swap on a 24GB card. Our Qwen3.8-27B VRAM guide covers which quant fits 12, 16 and 32GB.
• Gemma 4 is the family to know. Five sizes — e2b, e4b, 12b, 26b (MoE), 31b (dense) — all take images, the two small ones take audio, and Google's own table on the model page puts the 31B at 85.2 MMLU Pro and 80.0 LiveCodeBench v6. Full breakdown in our Gemma 4 guide.
• Meta's Muse Glimmer is an agent model, not a chat model. Meta's table lists it ahead of Gemma 4 31B and Qwen3.6-27B on MCP Atlas (75.5) and roughly level on SWE-Bench Verified (76.0 vs 77.2 for Qwen3.6-27B). It is 18GB, Apache 2.0, and has an 30b-mlx tag for Apple Silicon — see Muse Glimmer 30B.
• MoE is now the middle lane. gemma4:26b, qwen3.6:35b, qwen3-coder:30b and nemotron-3.5-lightning:30b all hold 25–35B parameters on disk but activate 3–4B per token, so they generate closer to a 7B's rate while reasoning closer to their full size. They still need the whole file resident in VRAM. If your VRAM tops out at 24GB, run the largest model of the right kind that fits 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 remain excellent and very widely deployed; the new 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 for the exact Q4/Q8/FP16 file size of every family, the Ollama model RAM & VRAM table. 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.

---

Best Ollama Model for Coding

On a 24GB GPU, pull qwen3-coder:30b — a 30B MoE with a 256K native context that generates at small-model speed (19GB download). If you want one model for coding and everything else, qwen3.8:27b (18GB) is the stronger all-rounder: Alibaba's card lists LiveCodeBench v6 90.3 and Terminal-Bench 2.1 73.0. On an 8GB card, use qwen2.5-coder:7b; for editor autocomplete use qwen2.5-coder:1.5b.

Why Qwen owns local coding: the Qwen 2.5 Coder line is still the most-pulled coding family in the library (23.2M pulls), and the Qwen3 generation stacks MoE on top: qwen3-coder:30b activates a few billion 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. Qwen3.8-27B then folds coding into a general model good enough that many single-GPU users now run only it.

Best setup for AI-assisted coding:

• Use Qwen 2.5 Coder 1.5B for fast autocomplete in Continue.dev or Cursor (compared with the other editors in best AI coding tools)
• 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 still the best local chat model if you have the hardware. For most people with one good GPU, Qwen3.8-27B or Gemma 4 26B hits the sweet spot of quality and footprint, and both take images, which Llama 3.3 does not.

Gemma 4 E4B is the surprise at the small end: Google's table puts it at 69.4 MMLU Pro, a point above Gemma 3 27B (67.6), in a 6.6GB download that also listens to audio.

If what you mostly do is fiction, long-form drafting, copy or editing, the picks and the sampler settings that stop repetition are different from general chat; they are in our guide to the best local AI models for writing.

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. The Ollama model page says the 1.5B–32B distills are "derived from the Qwen-2.5 series", the 8B is the newer DeepSeek-R1-0528 distill on Qwen3, and the 70B is derived from Llama 3.3 70B. DeepSeek publishes its scores for the full-precision weights, so we deliberately do not restate them for the quantized Ollama builds.

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 plain-chat reply. Budget for that before you make a thinking model your default — or use gpt-oss and set the effort to low for everyday questions.

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 still the standard choice for RAG with Ollama — it is the most-pulled embedding model in the library (95.1M) and works with Open WebUI, AnythingLLM, and most RAG frameworks. embeddinggemma-2 is the one to try if your corpus has images or very long chunks. Our best Ollama embedding models for RAG page lines them up 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 CLI form is simply ollama run gemma4 ./image.png what is in this image?. See our comparison of the best local vision models for how Qwen3-VL, Gemma 4, 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, 4.9GB), dolphin-mistral (7B, 4.1GB), and dolphin-mixtral (8x7B MoE, 26GB). 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.8 or Gemma 4 — 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, embedding and decision 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 download the library lists for the bolded size (all read on 2 November 2026). For Q4/Q8/FP16 file sizes and minimum VRAM per model beyond this summary, see the full Ollama model RAM & VRAM table.

Download figures are what the library's tag page listed for the bolded size on 2 November 2026 (a range means the tag resolves to different quantizations on different hardware — Ollama ships MLX builds for Apple Silicon and GGUF elsewhere). Add roughly 1–2GB for the KV cache at the 4096-token default context, more if you raise num_ctx. 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 2B–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 gemma4:e2b         # 4.6GB - text + image + audio, 128K context
ollama pull llama3.2           # 2.0GB - fastest useful chat model
ollama pull phi4-mini          # 2.5GB - small and capable
ollama pull gemma2:2b          # 1.6GB - lightest of the lot

16GB RAM / 8GB VRAM (RTX 3060 8GB, RTX 4060, 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 gemma4:e4b         # 6.6GB - text + image + audio
ollama pull llama3.1:8b        # 4.9GB - the most-pulled general model
ollama pull qwen2.5-coder:7b   # 4.7GB - best coding 7B
ollama pull deepseek-r1:8b     # 5.2GB - chain-of-thought reasoning
ollama pull qwen3-vl:4b        # 3.3GB - image understanding
ollama pull nomic-embed-text   # 274MB - embeddings for RAG

12GB VRAM (RTX 3060 12GB, RTX 4070)

# Best picks for 12GB VRAM
ollama pull gemma4:12b         # 7.7-8.0GB - text + image, 256K context
ollama pull deepseek-r1:14b    # 9.0GB - reasoning
ollama pull phi4               # 9.1GB - Microsoft's 14B
ollama pull deepseek-coder-v2:16b  # 8.9GB - MoE coder, 160K context

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

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

# Best picks for 16GB VRAM
ollama pull gpt-oss:20b        # 14GB - OpenAI open-weight MoE, "as little as 16GB memory"
ollama pull gemma4:26b         # 16-19GB - fits the 16GB QAT build, tight
ollama pull qwen3:14b          # 9.3GB - dense 14B all-rounder
ollama pull devstral:24b       # 14GB - agentic coding

24GB VRAM (RTX 3090, 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.8:27b         # 18GB - best overall: text + image + video
ollama pull gemma4:31b          # 19-20GB - strongest dense Gemma
ollama pull qwen3-coder:30b     # 19GB - agentic coding, 256K context, MoE speed
ollama pull muse-glimmer:30b    # 18GB - Meta's local agent model
ollama pull deepseek-r1:32b     # 20GB - strongest R1 distill that fits

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

Run 70B models and the large MoE cards.

# Best picks for 48GB+
ollama pull llama3.3:70b       # 43GB - Meta's 70B generalist
ollama pull qwen2.5:72b        # 47GB - multilingual
ollama pull gpt-oss:120b       # 65GB - "fit on a single 80GB GPU" (card)
ollama pull llama4:scout       # 67GB - 10M-token context

---

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 the download size the library lists for the tag — 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 a model from Q8_0 to Q4_K_M roughly halves the file (qwen3.8:27b-q8_0 is 30GB, qwen3.8:27b-q4_K_M is 18GB on the library) and raises the ceiling by the same ratio. 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. gemma4:26b holds 25.2B parameters but activates 3.8B per token, so it reads far less than its 16–19GB footprint per token and generates closer to a small model's rate. It still needs the full file resident.

What a real machine actually does

The ceiling is the limit; here is how far below it one machine lands. This is the only measured table on this site — the same prompt, the same number of runs, every model, on one Apple M3 Pro — and it is reproduced here verbatim from the benchmark file rather than retyped:

Measured on an Apple M3 Pro, 18 GB unified memory, Ollama 0.12.3, macOS (Darwin 27.0.0, arm64), Metal, 14–15 October 2026. Median generation rate of 6 runs after a discarded warm-up, computed from Ollama's raw eval_count and eval_duration over its HTTP API (not scraped from the terminal); any run that produced fewer than 30 tokens is thrown out rather than averaged. The same prompt, 7 runs, for every model. Ceiling = 150 GB/s (Apple's figure for the M3 Pro) ÷ the file size Ollama downloaded. One machine is a data point, not a survey; the script is scripts/benchmark-ollama.py in our repo if you want the same table for yours.

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 and the Ollama troubleshooting guide cover the usual causes, and the Ollama system requirements guide sets the floor for each size class.

---

How to Pick the Right Model

Decision Flowchart

Step 1: What's your VRAM?

• Under 4GB → llama3.2:1b (1.3GB) or gemma2:2b (1.6GB)
• 4-8GB → gemma4:e4b, llama3.1:8b, qwen2.5-coder:7b
• 8-16GB → gemma4:12b, deepseek-r1:14b, gpt-oss:20b (16GB)
• 16-24GB → qwen3.8:27b, gemma4:31b, qwen3-coder:30b
• 24GB+ → llama3.3:70b, gpt-oss:120b

Step 2: What's your primary use case?

• General chat → Qwen3.8-27B on a 24GB card, else Gemma 4 / Llama 3.1 (largest that fits)
• Coding → qwen3-coder:30b on 24GB, else Qwen 2.5 Coder (largest that fits)
• Reasoning/math → gpt-oss:20b on 16GB, else DeepSeek R1 (largest that fits)
• Images or PDFs with figures → Gemma 4 or Qwen3-VL (largest that fits)
• Fast autocomplete → Qwen 2.5 Coder 1.5B
• Document Q&A → Llama 3.1 8B or Gemma 4 12B + nomic-embed-text

Step 3: Speed vs Quality?

• Need fast responses → Pick one size down from your maximum, or an MoE (gemma4:26b, qwen3.6:35b)
• 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 is a better coding model than Llama 3.1 8B despite being smaller. Use specialized models.
3. Ignoring quantization — Use the default tag (Q4_K_M on most families). Full precision wastes VRAM with negligible quality gain.
4. Chasing parameter count — A 26B MoE with 3.8B active (Gemma 4 26B) out-scores Gemma 3 27B dense on every row of Google's table. Training and architecture matter more than size alone.
5. Forgetting the context default — Ollama uses a 4096-token context unless you raise num_ctx; a "256K" model does not give you 256K until you ask for it, and asking for it costs VRAM.

---

Model Management Tips

Check Installed Models

ollama list
# NAME                     ID            SIZE     MODIFIED
# llama3.1:8b              46e0c10c039e  4.9 GB   2 days ago
# qwen2.5-coder:7b         ...           4.7 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   (move it with OLLAMA_MODELS)

Pull Specific Quantizations

# Default tag — Q4_K_M on most families
ollama pull qwen3.8:27b                 # 18GB

# Higher quality — Q8_0, roughly 1.7x the bytes
ollama pull qwen3.8:27b-q8_0            # 30GB

# Full precision — bf16, for workstations only
ollama pull qwen3.8:27b-bf16            # 56GB

# Google's quantization-aware builds of Gemma 4 are a little smaller than Q4_K_M
ollama pull gemma4:26b-a4b-it-qat       # 16GB vs 18GB for 26b-a4b-it-q4_K_M

Set Context Window Size

# In Ollama chat, increase context window (default is 4096 tokens):
/set parameter num_ctx 16384

# Or set it for every model with an environment variable:
# OLLAMA_CONTEXT_LENGTH=16384

# Or create a Modelfile for persistent settings:
# FROM llama3.1:8b
# PARAMETER num_ctx 16384
# 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 Qwen3.8-27B 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. Ollama also ships its own MLX engine for Apple Silicon, which is why many tags on the library now show a size range.
• 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.8:27b — a dense 27B with a vision encoder, a 262,144-token native context and an Apache 2.0 licence, 18GB to download. Alibaba's card lists LiveCodeBench v6 90.3 and GPQA Diamond 89.2. Install it with ollama pull qwen3.8:27b. With 48GB+ of VRAM or a 64GB Mac, Llama 3.3 70B is still the strongest dense generalist. On 8GB, Gemma 4 E4B (images and audio too) or Llama 3.1 8B (text only, most-pulled model in the library).

What is the best Ollama model for coding?

On a 24GB GPU, qwen3-coder:30b — a 30B MoE with a 256K native context that generates at small-model speed and is a 19GB download. If you want one model for coding and general work, qwen3.8:27b is the better all-rounder. Qwen 2.5 Coder 32B is still the most-pulled dense coder (Aider 73.7 per Qwen). Smaller setups: Qwen 2.5 Coder 7B on 8GB, Qwen 2.5 Coder 1.5B (986MB) for autocomplete.

Which Ollama models support tools, thinking, vision, and embeddings?

Use the library's own filters: Tools, Thinking, Vision, Embedding and Cloud. Our picks per filter are in the category table above: gpt-oss 20B for thinking, Qwen3.8 27B for tools, Gemma 4 12B for vision, EmbeddingGemma 2 or nomic-embed-text for embeddings, gemma4:cloud when you have no GPU at all. Qwen3.8, Qwen3.6, Qwen3.5, Gemma 4 and Muse Glimmer carry all three local labels at once.

What are Ollama cloud models?

Tags ending in :cloud (gemma4:cloud, gpt-oss:120b-cloud, deepseek-v4.1-flash:cloud, glm-5.3:cloud) run on Ollama's servers instead of your GPU. Nothing downloads; you sign in once and use the same ollama run command. They are the only models on this page that send your prompt off your machine, and you can disable the feature with OLLAMA_NO_CLOUD=1.

How much VRAM do I need for Ollama models?

Take the download size the library lists for the tag, then add 1-2GB for the KV cache at the default 4096-token context — more if you raise num_ctx. A 7B needs ~6GB, a 14B ~11GB, a 27B ~20GB, a 70B ~45GB. Apple Silicon draws on unified memory, so a 36GB M3 Pro can hold a 27B. NVIDIA cards need it in dedicated VRAM: an RTX 3060 12GB handles up to 14B, an RTX 4090 24GB handles the 27B–32B class, an RTX 5090 32GB handles a 70B only at a 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: Gemma 4 E2B (4.6GB), Llama 3.2 3B (2.0GB), Phi-4 Mini (2.5GB), Gemma 2 2B (1.6GB) and Qwen 2.5 Coder 1.5B (986MB) all run. Llama 3.1 8B technically fits but leaves nothing for context. With 8GB of VRAM (an RTX 4060, say): Gemma 4 E4B, Llama 3.1 8B, Mistral 7B and Qwen 2.5 Coder 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 under 1GB for a small embedder to 43GB for a 70B. On Windows, the Ollama Windows installation guide gets you from download to first model.

Should I use quantized or full-precision models?

Quantized, effectively always. The default tag on most families is Q4_K_M, which is roughly a third of the bf16 bytes (qwen3.8:27b is 18GB at Q4_K_M and 56GB at bf16 on the library) for a quality difference most people cannot detect in normal use. If you have headroom and want the last few percent, Q8_0 costs about 1.7x the memory (30GB for the same model).

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 14B up together. Idle models unload after five minutes by default; change that with the OLLAMA_KEEP_ALIVE environment variable, and cap how many stay loaded with OLLAMA_MAX_LOADED_MODELS.

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 1.5B model has roughly five times the ceiling of a 4.9GB 8B on the same card. Llama 3.2 3B is the best speed-to-quality trade-off in practice (it is also the top row of the measured table above); Qwen 2.5 Coder 1.5B is the usual autocomplete pick.

---

Key Takeaways

1. qwen3.8:27b is the best single-GPU model — dense 27B, text + image + video, 262K context, 18GB
2. gemma4 is the family to learn: E2B/E4B for laptops, 12B for 12GB cards, 26B MoE for speed, 31B for quality — all take images
3. qwen3-coder:30b is the best coding pick for 24GB cards; Qwen 2.5 Coder 7B on 8GB
4. gpt-oss:20b is the best 16GB-card model and the best thinking model with an effort dial
5. Llama 3.3 70B is still the best model if you have 48GB+ VRAM/RAM
6. The library's filters are the map — Tools, Thinking, Vision, Embedding, Cloud — and the category table above names a pick for each
7. Use the default tag (Q4_K_M) and raise num_ctx deliberately; the 4096-token default is the usual surprise
8. nomic-embed-text is the go-to embedding model for RAG; embeddinggemma-2 when you need images or long chunks

---

Next Steps

1. Install Ollama on Windows — download to first model in five minutes, no admin rights needed
2. Set up Open WebUI for a ChatGPT-like interface with your models
3. Find models for 8GB RAM if you're on limited hardware
4. Set up Continue.dev for AI coding with Ollama
5. Compare Jan vs LM Studio vs Ollama for model management
6. Check VRAM requirements for detailed GPU sizing
7. Run GPT-OSS locally — OpenAI's open-weight model on Ollama
8. Run Llama 4 Scout locally — Meta's MoE with a 10M-token context
9. Try Qwen3-Coder — Alibaba's agentic coding model
10. Ollama image generation: what works now — the honest state of text-to-image in Ollama

---

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 2 November 2026 against Ollama v0.40.13. Every throughput figure on this page is either arithmetic you can reproduce or the one measured table reproduced from the benchmark file; where a number comes from a vendor, it says so.