Best Ollama Models for 8GB, 12GB, 16GB & 24GB VRAM (Full Table)

Published on April 11, 2026 · Updated August 2026 · 19 min read

Quick answer: the best Ollama models by GPU are Llama 3.1 8B for 8GB VRAM (Qwen 2.5 Coder 7B if you code), Qwen 2.5 14B for 12GB, Gemma 3 27B for 16GB, and Qwen 2.5 32B — or the much faster MoE Qwen 3 30B-A3B — for 24GB. Here is the RAM/VRAM each popular model needs at Q4_K_M (the default quant), plus the minimum GPU/unified memory to load it fully on-GPU. Full per-family tables and benchmarks are further down.

Rule of thumb: min VRAM ≈ the Q4_K_M file size + ~1–1.5GB overhead (KV cache at 2K context). Best pick for 6GB: a 3–4B at Q4 (laptop GPUs); 8GB: Llama 3.1 8B (general) or Qwen 2.5 Coder 7B (code); 12GB: a 14B at Q4; 16GB: Gemma 3 27B Q4_K_M; 24GB: Qwen 2.5 32B Q4_K_M; 32GB: a 32B at Q5/Q6 with full context on an RTX 5090. Each of those links ranks the full shortlist for that card. RAM vs VRAM: models run fastest fully in VRAM; if they spill to system RAM, expect 2–10× slower generation.

Want the math done for a specific model and context length? Plug your numbers into our interactive VRAM calculator. For the full picture on CPU, disk, and OS-level needs beyond raw model size, see the Ollama system requirements guide.

---

I got tired of googling "how much VRAM does Llama 70B need" every time I set up a new machine. So I measured every popular Ollama model at every common quantization level, on real hardware, with real numbers.

Bookmark this page. It is the reference table I wish existed when I started running local models.

---

How to Read This Table {#how-to-read-this-table}

Each model entry includes:

• Q4_K_M size — 4-bit quantization, the sweet spot for most users (minimal quality loss, biggest memory savings)
• Q5_K_M size — 5-bit quantization, slightly better quality, ~20% more memory
• FP16 size — Full precision, maximum quality, 2x memory vs Q4
• Min VRAM — The minimum VRAM needed to load the Q4_K_M version entirely on GPU (includes ~1GB overhead for KV cache at 2K context)
• tok/s RTX 3060 — Generation speed on RTX 3060 12GB (entry-level AI GPU)
• tok/s RTX 4090 — Generation speed on RTX 4090 24GB (high-end consumer)
• tok/s M4 Max — Generation speed on Apple M4 Max 48GB unified memory

All benchmarks measured with: Ollama 0.30.x (the mid-2026 branch that added the MLX backend on Apple Silicon), 512-token prompt, 256-token generation, single request, models fully loaded in VRAM (no CPU offload). As of this August 2026 refresh the current release branch is 0.32.x — see the Ollama version history for what changed. Treat tok/s figures as approximate — they shift a few percent between Ollama point releases and driver versions.

---

Llama 3.x Family {#llama-3x-family}

The workhorse family. Meta's Llama models are the most-used open-weight models for good reason — strong quality across the board.

Notes:

• Llama 3.1 8B is the single most popular Ollama model. It fits on any 8GB GPU with room to spare.
• Llama 3.3 70B at Q4_K_M needs 42GB — runs on M4 Max 48GB or dual 24GB GPUs. Does not fit on a single RTX 4090.
• Llama 3.1 405B is impractical for consumer hardware. Included for completeness. Requires 4x A100 80GB or equivalent.

# Pull Llama models
ollama pull llama3.2:1b
ollama pull llama3.2:3b
ollama pull llama3.2        # defaults to 8B Q4_K_M
ollama pull llama3.3:70b-instruct-q4_K_M

---

How Much VRAM Does Llama 4 Need? {#llama-4-family}

Meta's Llama 4 generation is built on Mixture-of-Experts (MoE), so the memory math is different from the dense Llama 3.x models above. You still have to fit every expert weight in memory (so the file is large), but only a fraction of parameters activate per token (so it runs faster than a dense model of the same total size). This is the single most common point of confusion people hit when sizing hardware for Llama 4.

Notes:

• Llama 4 Scout is the smallest Llama 4 and still needs roughly 55–60GB at Q4_K_M because all 16 experts must be resident. It does not fit a single 24GB consumer GPU — plan on a 64GB+ Apple Silicon machine, dual RTX 5090s (64GB combined), or a data-center card. Once loaded, it generates at the speed of a ~17B dense model thanks to MoE routing.
• Llama 4 Maverick is firmly server-class. Treat it like the 405B entry in the table: included for completeness, not for a desktop.
• If Llama 4 is out of reach, a Q4_K_M Llama 3.3 70B (40GB) on 48GB Apple Silicon remains the most accessible top-tier Llama for local use. Verify the exact tag and size against the official Ollama library before pulling, since MoE quant sizes vary by release.

---

Qwen 2.5 / Qwen 3 Family {#qwen-25--qwen-3-family}

Alibaba's Qwen models punch above their weight on code, math, and multilingual tasks. Qwen 2.5 Coder is the best local coding model at every size.

Notes:

• Qwen 2.5 7B is the go-to if you want code+math strength on an 8GB GPU.
• Qwen 2.5 14B Q4_K_M at 8.7GB barely fits on a 12GB RTX 3060 — you get it running but context window is limited.
• Qwen 2.5 32B is the sweet spot for 24GB GPUs. Fits with room for a decent context window.
• Qwen 3 models use a hybrid thinking architecture (think/no-think modes). Slightly larger than Qwen 2.5 at the same parameter count.
• Qwen 3 30B-A3B is the standout for 24GB GPUs in 2026. It is a Mixture-of-Experts model: ~30B total params (so the file is ~16.8GB at Q4_K_M and needs ~18GB to load), but only ~3.3B activate per token. The result is 32B-class quality running at roughly the speed of a 3-4B model — comfortably 40+ tok/s on a 24GB card. If you have the VRAM, it is often a better pick than the dense Qwen 3 32B for interactive use.
• Qwen3.6 27B (ollama pull qwen3.6:27b) is the newest dense pick for 24GB cards — ~17GB at Q4_K_M and ~30 tok/s on an RTX 4090; the Qwen3.6-27B guide has full specs, quant sizes and VRAM figures.

# Pull Qwen models
ollama pull qwen2.5:0.5b
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b
ollama pull qwen3:8b
ollama pull qwen3:14b
ollama pull qwen3:30b-a3b      # MoE, ~16.8GB, fits 24GB
ollama pull qwen3:32b

---

Gemma 3 & Gemma 4 Family {#gemma-3-family}

Google's Gemma 3 models are surprisingly strong at small sizes. Gemma 3 4B punches way above its weight and is a top pick for constrained devices. The Gemma 4 generation landed in summer 2026 — measured Gemma 3 numbers first, then the Gemma 4 planning estimates.

Notes:

• Gemma 3 4B at 2.5GB Q4_K_M is excellent for Raspberry Pi 5 (8GB) or old laptops.
• Gemma 3 12B is a strong 12GB GPU choice, rivaling models twice its size on instruction following.
• Gemma 3 27B fits on a single RTX 4090 (24GB) at Q4_K_M with tight context, or comfortably on 32GB Apple Silicon.

# Pull Gemma models
ollama pull gemma3:1b
ollama pull gemma3:4b
ollama pull gemma3:12b
ollama pull gemma3:27b

Gemma 4 (Summer 2026) {#gemma-4}

Gemma 4 12B Unified needs roughly 7-8GB at Q4, so a 12GB card runs it comfortably — and both the 26B-A4B MoE and the 31B dense flagship fit a single 24GB card quantized. The whole family ships under Apache 2.0. One caveat before the table: these are planning estimates from standard Q4 arithmetic (Google publishes hardware targets, not GGUF file sizes), and we have not benchmarked tok/s yet, so no speed columns until we have measured numbers.

Notes:

• The tiny E2B (~2.3B effective) and E4B (~4.5B effective) members run fully offline on phones and Raspberry Pi-class hardware — they are the pick below 8GB.
• The 12B Unified handles text, audio, and images in one model with a 256K context. Long context costs VRAM on top of the weights, so treat 12-16GB as the practical floor if you actually want that window.
• Check the current tags on the official Ollama library before pulling, and see our full Gemma 4 hardware guide for the tier-by-tier breakdown.

---

Phi-4 Family {#phi-4-family}

Microsoft's Phi-4 models achieve remarkable reasoning for their size. Phi-4 3.8B consistently beats 7B models from other families on logic and math tasks.

Notes:

• Phi-4 Mini at 2.3GB Q4_K_M is the best reasoning model you can fit on a 4GB GPU.
• Phi-4 14B needs a 12GB GPU minimum. Performance is excellent for code review and analytical tasks.

# Pull Phi models
ollama pull phi4-mini       # 3.8B
ollama pull phi4            # 14B

---

Mistral / Mixtral Family {#mistral--mixtral-family}

Mistral's models and their Mixture-of-Experts (MoE) Mixtral variants. MoE models use more disk space but activate only a fraction of parameters per token, giving better quality per FLOP.

Notes:

• Mistral 7B is a solid all-rounder, competitive with Llama 3.1 8B. Slightly smaller file size.
• Mixtral 8x7B has 46.7B total params but only activates 12.9B per token. Needs 28GB VRAM but runs at the speed of a ~13B model. Quality approaches 70B dense models.
• Mixtral 8x22B is a server-class model. 80GB minimum VRAM. Requires A100 80GB or multi-GPU.

# Pull Mistral/Mixtral models
ollama pull mistral          # 7B
ollama pull mistral-small    # 24B
ollama pull mixtral          # 8x7B

---

DeepSeek R1 Distills {#deepseek-r1-distills}

DeepSeek's R1 reasoning model distilled into smaller architectures. These models "think" step-by-step and show their reasoning chain.

Notes:

• R1 distills have the same VRAM requirements as their base models (same architecture, same parameter count).
• The "thinking" tokens add output length. A simple question might generate 500+ reasoning tokens before the final answer. Budget more output tokens.
• R1 7B on an 8GB GPU gives you step-by-step reasoning that rivals much larger non-reasoning models on math and logic.

# Pull DeepSeek R1 distills
ollama pull deepseek-r1:1.5b
ollama pull deepseek-r1:7b
ollama pull deepseek-r1:8b
ollama pull deepseek-r1:14b
ollama pull deepseek-r1:32b
ollama pull deepseek-r1:70b

---

Code Models {#code-models}

Specialized models for code generation, completion, and review. These are fine-tuned on code and perform better than general-purpose models on programming tasks.

Notes:

• The Qwen 3 wave changed the coding pecking order. Qwen3-Coder 30B (MoE, only ~3B params active per token) delivers 32B-class code at ~50 tok/s on a 24GB card, with a 256K native context built for agent workflows. Qwen 2.5 Coder 32B is still the strongest dense coder and a fine choice if you already run it, but the MoE is the one to pull first. Full rankings in our best local coding models guide.
• If you only have 16GB, Qwen3-Coder-Next (80B total, 3B active) is the surprise: agent-grade coding on a 16GB machine — ollama run qwen3-coder-next.
• Qwen 2.5 Coder 7B is the best coding model for 8GB GPUs. Outperforms CodeLlama 13B despite being smaller.
• CodeLlama is aging but still widely used. If you are already using it, consider switching to Qwen 2.5 Coder at the same size.
• StarCoder2 excels at code completion (fill-in-the-middle) rather than instruction following.

# Pull code models
ollama pull qwen3-coder:30b     # MoE, ~18GB, fits 24GB
ollama pull qwen3-coder-next    # 3B active, runs on 16GB
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:14b
ollama pull qwen2.5-coder:32b
ollama pull codellama:7b
ollama pull codellama:13b
ollama pull codellama:34b
ollama pull starcoder2:3b
ollama pull starcoder2:7b
ollama pull starcoder2:15b

---

Legacy Models: Llama 2 Memory Requirements {#llama-2-memory-requirements}

Llama 2 7B at FP16 needs ~14GB of VRAM (13.5GB of weights plus KV cache); at Q4_K_M it drops to ~4.1GB and runs on any 6GB GPU. The 13B and 70B follow the same math: two bytes per parameter at FP16, roughly 30% of that at Q4_K_M.

Notes:

• Running Llama 2 7B unquantized (FP16) means a 16GB card — it does not fit 12GB once the KV cache is counted. In practice almost nobody should: Q4_K_M carries the usual 1-3% quality cost at less than a third of the memory.
• Ollama's default llama2 tags ship Q4_0, slightly smaller than Q4_K_M: 3.8GB for 7B, 7.4GB for 13B, 39GB for 70B.
• Llama 2 is two generations old. Unless you are reproducing older research or maintaining an existing pipeline, Llama 3.1 8B beats Llama 2 13B across the board at a third of the memory.

# Pull Llama 2 (legacy)
ollama pull llama2          # 7B, Q4_0
ollama pull llama2:13b
ollama pull llama2:70b

---

Quick Reference: What Fits on Your GPU {#quick-reference-what-fits-on-your-gpu}

Find your GPU (or unified memory) capacity and see what models you can run at full speed (100% VRAM, no CPU offload).

8GB VRAM (RTX 3060 8GB, RTX 4060, M1/M2 8GB)

Top pick: Llama 3.1 8B Q4_K_M for general use, Qwen 2.5 Coder 7B for programming.

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

Everything from 8GB, plus:

Top pick: Qwen 2.5 14B Q4_K_M. The jump from 7B to 14B is the single biggest quality improvement per dollar in local AI. If you are still choosing a card rather than sizing one you own, our RTX 5070 for local AI breakdown covers exactly what 12GB runs and when paying up for 16GB is worth it.

16GB VRAM (RTX 4080, RTX 5060 Ti, M1 Pro/M2 Pro 16GB)

Everything from 12GB, plus:

Top pick: Gemma 3 27B Q4_K_M squeezes in and delivers impressive quality.

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

Everything from 16GB, plus:

Top pick: Qwen 2.5 32B Q4_K_M. Best overall model that fits on a single consumer GPU. This is the sweet spot.

32GB Unified Memory (M2 Pro/Max 32GB, M3 Pro 36GB)

Everything from 24GB at slightly lower speed, plus:

48GB+ Unified Memory (M3 Max 48GB, M4 Max 48GB+)

Everything from 32GB, plus:

Top pick: Llama 3.3 70B Q4_K_M. Running a 70B model on a laptop is genuinely impressive. Speed is acceptable for interactive use.

64GB+ (M4 Ultra, dual GPU, server)

Everything from 48GB, plus:

For more on choosing hardware for your target models, see our RAM requirements guide and VRAM requirements guide.

---

Ollama Pull Commands: Every Model {#ollama-pull-commands-every-model}

Copy-paste ready. Every model referenced in this article:

# === LLAMA FAMILY ===
ollama pull llama3.2:1b
ollama pull llama3.2:3b
ollama pull llama3.2                     # 8B, default quant
ollama pull llama3.3:70b-instruct-q4_K_M

# === QWEN FAMILY ===
ollama pull qwen2.5:0.5b
ollama pull qwen2.5:1.5b
ollama pull qwen2.5:3b
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b
ollama pull qwen3:8b
ollama pull qwen3:32b

# === GEMMA FAMILY ===
ollama pull gemma3:1b
ollama pull gemma3:4b
ollama pull gemma3:12b
ollama pull gemma3:27b

# === PHI FAMILY ===
ollama pull phi4-mini
ollama pull phi4

# === MISTRAL/MIXTRAL ===
ollama pull mistral
ollama pull mistral-small
ollama pull mixtral

# === DEEPSEEK R1 DISTILLS ===
ollama pull deepseek-r1:1.5b
ollama pull deepseek-r1:7b
ollama pull deepseek-r1:8b
ollama pull deepseek-r1:14b
ollama pull deepseek-r1:32b
ollama pull deepseek-r1:70b

# === CODE MODELS ===
ollama pull qwen3-coder:30b
ollama pull qwen3-coder-next
ollama pull qwen2.5-coder:1.5b
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:14b
ollama pull qwen2.5-coder:32b
ollama pull codellama:7b
ollama pull codellama:13b
ollama pull codellama:34b
ollama pull starcoder2:3b
ollama pull starcoder2:7b
ollama pull starcoder2:15b

# === LEGACY (LLAMA 2) ===
ollama pull llama2
ollama pull llama2:13b
ollama pull llama2:70b

Browse the full model library at ollama.com/library.

---

How Much Does Context Length Add to VRAM? {#context-length-vram}

The "Min VRAM" column in every table above assumes a modest 2K-token context. In real use — long chats, RAG pipelines, agents, large code files — the KV cache grows with context length and can quietly become the thing that pushes you out of VRAM. This is the #1 reason a model that "should fit" suddenly spills to CPU. RAG setups pay a second tax: an embedder sits in VRAM alongside the chat model, though the best Ollama embedding models for RAG are small enough that a few hundred MB to ~1GB covers it.

The KV cache scales roughly linearly with context. A useful approximation for a typical dense model at Q4_K_M:

Extra VRAM for context ≈ 0.5 GB per 2K tokens (7-8B model)
                       ≈ 1.0 GB per 2K tokens (14B model)
                       ≈ 1.5-2.0 GB per 2K tokens (32B+ model)

Notice what this means in practice: a 32B model that fits a 24GB GPU at 2K context will not fit the same card at 32K context — it needs ~36GB. If you run long-context workloads, size your hardware against the right-hand column, not the headline number. Two ways to claw back memory: enable KV-cache quantization (OLLAMA_KV_CACHE_TYPE=q8_0 roughly halves cache size at a tiny quality cost), or set a smaller num_ctx for the model. These are approximate; exact KV-cache size depends on the model's head count and hidden dimension. The broader VRAM requirements guide covers bandwidth and bus-width effects on top of capacity.

If you are working with a tight memory budget, the safest move is to drop a size class and run a smaller model at a longer context rather than a bigger model that constantly spills — see the best local AI models for 8GB RAM for picks that leave headroom for context.

---

Memory Math: How to Calculate Any Model {#memory-math-how-to-calculate-any-model}

If a model is not in this table, you can estimate its VRAM requirement:

FP16 size (GB)  = Parameters (B) × 2
Q4_K_M size     ≈ FP16 × 0.28 to 0.32  (varies by architecture)
Q5_K_M size     ≈ FP16 × 0.34 to 0.38
Q8_0 size       ≈ FP16 × 0.50 to 0.55

Min VRAM needed = Model file size + 1.0 GB (KV cache at 2K context)
                  + 0.5 GB per 2K additional context tokens

Example: A new 20B model you want to run at Q4_K_M:

• FP16 size: 20 × 2 = 40GB
• Q4_K_M: 40 × 0.30 = ~12GB
• Min VRAM: 12 + 1.0 = ~13GB
• Fits on a 16GB GPU with room for 4K context

For a thorough explanation of quantization levels and their quality tradeoffs, read our quantization explained guide. To find the best models for tight memory budgets, see best models for 8GB RAM.

---

Frequently Asked Questions {#faq}

See the FAQ section below for answers to common questions about Ollama memory requirements.

---

Keep This Bookmarked

This table gets updated as new models release — the August 2026 refresh added Gemma 4, the Qwen 3 coder wave, and the Llama 2 legacy table. The Ollama ecosystem moves fast — new model families appear every few weeks, and existing ones get updated quantization options.

The core principle stays constant: check the Q4_K_M file size, add 1-1.5GB for overhead, and compare against your available VRAM. If it fits with room to spare, you will have a good experience. If it barely fits, expect limited context windows and occasional slowdowns.

---

Building a new machine around a specific model? Start with the hardware requirements guide to size your GPU, RAM, and storage correctly.