Wednesday, 18 November 2026 | Updating Daily AI insight, written for builders

Ollama Models List (2026): Every Popular Model, Size & RAM

Updated · Originally published

Which models can you run with Ollama right now? As of November 2026 the official Ollama library lists 270 model families, most in several sizes. The most-pulled chat models are Llama 3.1, DeepSeek-R1, Llama 3.2, Qwen 2.5, Qwen3 and Gemma 3; the current generation to start with is Google’s Gemma 4, Alibaba’s Qwen 3.5, 3.6 and 3.8 and OpenAI’s gpt-oss. Each is one command away, for example ollama run gemma4:e4b or ollama run qwen3.5:9b.

This practical Ollama models list covers the models people actually run, what each needs in memory and what each is good at, plus how to list the models you already have and pull new ones. For most models Ollama downloads a 4-bit quantised build by default, which is why a “70B” model can fit on a good workstation and an “8B” runs on a laptop. Sizes below are the defaults listed on ollama.com and move with each release — always check the AI models database or run ollama list for what is current on your machine.

Quick reference

  • Run on any laptop (8 GB RAM): Qwen 3.5 2B/4B, Llama 3.2 3B, Gemma 3 4B, Bonsai 2 9B — small, fast, offline.
  • Best all-round (16 GB): Qwen 3.5 9B, Gemma 4 E4B or 12B, gpt-oss 20B, Llama 3.1 8B — the sweet spot for most people.
  • High quality (24–32 GB / GPU): Qwen 3.6 27B/35B, Qwen 3.8 27B, Gemma 4 26B/31B, Muse Glimmer 30B.
  • Near-frontier (workstation, 48 GB to 96 GB+): Llama 3.3 70B, DeepSeek-R1 70B, gpt-oss 120B, Qwen 3.5 122B.
  • Reasoning: gpt-oss, DeepSeek-R1. Coding: Qwen3-Coder, Qwen 3.6 coding tags, Flint, MiMo V2.6. Vision: Gemma 4, Qwen 3.5, Qwen3-VL. Embeddings: nomic-embed-text, EmbeddingGemma 2.
  • The rule: pick by the memory you have — check any model with our free VRAM calculator.

Short answer: You can run any model in the official Ollama library that has a local download and fits in your memory: on 8 GB start with qwen3.5:4b, on 16 GB with qwen3.5:9b or gemma4:e4b, and on a 24 GB GPU with qwen3.8:27b, each one ollama pull away. Some new models, such as DeepSeek V4.1 Flash and Kimi K3.1 Pro, have only :cloud tags, so they run on Ollama’s servers, not on your machine. Our November 2026 picks give the pull command and download size for each local pick, and the full table below lists the memory every popular family needs.

Key Facts

  • 270 model families in the official library (7 November 2026), most in several sizes
  • Any laptop (8 GB RAM): Qwen 3.5 2B/4B, Llama 3.2 3B, Gemma 3 4B
  • The 16 GB sweet spot: Qwen 3.5 9B, Gemma 4 E4B/12B, gpt-oss 20B, Llama 3.1 8B
  • 24–32 GB/GPU: Qwen 3.6 27B/35B, Qwen 3.8 27B, Gemma 4 26B/31B — workstation: Llama 3.3 70B, gpt-oss 120B, Qwen 3.5 122B
  • Ollama pulls 4-bit quantised builds by default for most models — that is why a “70B” fits a good workstation
  • Specialists: Qwen3-Coder & Flint (code) · Gemma 4 / Qwen3-VL (vision) · nomic-embed-text & EmbeddingGemma 2 (embeddings) · gpt-oss & DeepSeek-R1 (reasoning)

Best Ollama models (November 2026)

These are our picks for each memory budget this month. Every command and download size below was checked on the model’s ollama.com tags page on 7 November 2026. The picks follow memory needs, the capabilities Ollama lists for each model (image input, tools, thinking) and how recently each family was updated; they are editorial picks, not benchmark results. “Download size” is the size of the tag in the command, and a range means that tag maps to more than one build, such as a 4-bit GGUF and an Apple-Silicon MLX version.

Model Pull command Download size Good for
Qwen 3.5 4B ollama pull qwen3.5:4b 3.3–4.0 GB Any laptop with 8 GB of RAM; reads images; 256K context
Bonsai 2 9B (Prism ML) ollama pull bonsai-2:9b 3.2 GB Tight on disk or memory: ternary weights, about half the size of a standard 4-bit build; reads images
Qwen 3.5 9B ollama pull qwen3.5:9b 6.6–7.6 GB All-rounder for 16 GB; reads images; 256K context
Gemma 4 E4B (Google) ollama pull gemma4:e4b 6.6–9.5 GB All-rounder for 16 GB; reads images; 128K context
MiMo V2.6 9B (Xiaomi) ollama pull mimo-v2.6 6.6–8.7 GB New this month: code and agent workflows on a 16 GB machine; reads images; supported from Ollama 0.40.15
gpt-oss 20B (OpenAI) ollama pull gpt-oss:20b 14 GB Reasoning with low, medium or high effort; the model card says it runs with as little as 16 GB of memory
Qwen 3.8 27B ollama pull qwen3.8:27b 18 GB 24 GB GPU: coding, research and long agent tasks; reads images
Gemma 4 31B (Google) ollama pull gemma4:31b 19–20 GB 24–32 GB: the largest Gemma 4 size; reads images; 256K context
Qwen3-Coder 30B ollama pull qwen3-coder:30b 19 GB Coding assistant on a 24 GB GPU; 256K context
Flint 40B (Recursive) ollama pull flint:40b 23 GB Local coding agents: a 39.8B mixture-of-experts model with about 2.5B parameters active per token
gpt-oss 120B (OpenAI) ollama pull gpt-oss:120b 65 GB Workstation reasoning; sized to fit a single 80 GB GPU
EmbeddingGemma 2 (Google) ollama pull embeddinggemma-2:740m 1.3 GB Embeddings for local RAG and search; Ollama lists text and image input for this tag (Google’s model card also covers video and audio)
LFM3 1.7B (Liquid AI) ollama pull lfm3 1.1–1.7 GB Smallest chat pick: local agents, tool calling and structured output; 256K context

Newer than the October table further down: Liquid AI’s LFM3 family (lfm3, lfm3-vl, lfm3-audio and lfm3-omni) arrived in late October, and Ollama 0.40.13 extended it from Apple Silicon to Linux and Windows. vLLM Semantic Router’s d3 decision models (2B, 4B, 9B and 27B) arrived with Ollama 0.40.11 and joined the decision category. In early November, Ollama 0.40.15 added support for Xiaomi’s local MiMo V2.6 9B (ollama run mimo-v2.6, fine-tuned from Qwen 3.5 9B for code and agent workflows) and the AutoTrust decision models (autotrust-jev, supported on Apple Silicon in that release). Perplexity’s 4B pplx-decider-flash and Kimi K3.1 Pro joined the library in the same week; Kimi K3.1 Pro is cloud-only (kimi-k3.1-pro:cloud), so it runs on Ollama’s servers, not on your machine. The current release is Ollama 0.40.16 (9 November 2026, per the GitHub releases page), so update Ollama before pulling the newest families.

The most popular Ollama models at a glance

Every model below is available with a simple ollama pull <name>. “Download” is the default size listed on ollama.com (a 4-bit build for most models; newer families show a range because the default tag maps to more than one build, such as a 4-bit GGUF and an Apple-Silicon MLX version); “Min memory” is a practical floor of system RAM (CPU) or VRAM (GPU) to run it comfortably. Sizes move with each release.

Model Params Download Min memory Best for
Llama 3.2 1B / 3B ~1.3 / 2 GB 4–8 GB Edge, phones, ultralight chat
Llama 3.1 8B ~4.9 GB 8–16 GB Most-pulled model in the library; proven all-rounder
Llama 3.3 70B ~43 GB 48 GB+ Large dense open model
Gemma 4 E2B / E4B / 12B / 26B / 31B ~4.6–20 GB 8–32 GB Current Google family: text + image, thinking modes
Gemma 3 270M–27B ~0.3–17 GB 4 GB+ Efficient (Google); 4B and up read images
Gemma 2 9B / 27B ~5.4 / 16 GB 12–32 GB Strong quality per size
Qwen 3.8 27B ~18 GB 24–32 GB Latest Qwen: coding, agents, image input
Qwen 3.6 27B / 35B (MoE) ~18–24 GB 24–32 GB Agentic coding (-coding tags)
Qwen 3.5 0.8B–122B ~1.2–81 GB 4 GB+ Multimodal, 256K context, widest size range
Qwen3 0.6B–235B ~0.5–142 GB 4 GB+ Dense and MoE, thinking variants
Qwen 2.5 0.5B–72B ~0.4–47 GB 4 GB+ Multilingual, wide size range
Qwen 2.5 Coder 0.5B–32B ~0.4–20 GB 4 GB+ Local coding assistant
gpt-oss (OpenAI) 20B / 120B ~14 / 65 GB 16 / 80 GB Open-weight reasoning, adjustable effort
Mistral 7B ~4.4 GB 8 GB Fast, reliable classic
Mistral Nemo 12B ~7 GB 16 GB Long 128k context
Mixtral 8x7B ~26 GB 32 GB+ Mixture-of-experts quality
Phi-4 14B ~9 GB 16 GB Reasoning in a small model
Phi-3 Mini 3.8B ~2.2 GB 8 GB Tiny but capable
DeepSeek-R1 (distill) 1.5B–70B ~1.1–43 GB 8 GB+ Step-by-step reasoning
LLaVA 7B–34B ~4.7–20 GB 8 GB+ Vision (older; Gemma 4 and Qwen 3.5 now read images too)
nomic-embed-text — ~0.3 GB 2 GB Embeddings for RAG/search

Want the cloud models these compare against on price and speed? The AI models database lists open and closed models side by side, and the AI API cost calculator shows when running locally beats paying per token.

New in the Ollama library (October 2026)

These families were added or refreshed between mid-September and late October 2026. The commands use explicit tags because a bare name does not always pull the size you expect — plain nemotron-3.5-bolt, for example, fetches the 25 GB 74B build, which does not yet run on Apple Silicon.

Model Run command Params Download Best for
Nemotron 3.5 Lightning (NVIDIA) ollama run nemotron-3.5-lightning:30b 30B MoE (3B active) ~19–25 GB Always-on agents, up to 1M-token context
Nemotron 3.5 Bolt (NVIDIA) ollama run nemotron-3.5-bolt:e4b E4B (8B, 4B effective) / 74B-A9B ~7.2–7.9 / 25 GB Compact vision model for local coding and tool use
Bonsai 2 (Prism ML) ollama run bonsai-2:9b 2B / 4B / 9B / 27B ~0.9 / 1.6 / 3.2 / 8.3 GB Ternary weights, about half the size of 4-bit builds; vision, tools, thinking
Flint (Recursive) ollama run flint:40b 39.8B MoE (~2.5B active) ~23 GB Local coding agents, 262K-token context
LFM2.5 (Liquid AI) ollama run lfm2.5:24b 8B / 24B ~5.2 / 15 GB Fast tool calling on consumer hardware (24B is the new size)
Nemotron 3 Nano (NVIDIA) ollama run nemotron-3-nano:4b 4B / 30B ~2.8–2.9 / 18–24 GB Efficient agentic model, now with a 4B size
EmbeddingGemma 2 (Google) ollama pull embeddinggemma-2:740m 270M–740M ~0.3–1.3 GB Multimodal embeddings: Ollama lists text input for every size and image input for the 440M and 740M sizes; Google’s model card also covers video and audio
Phonon (Gradium) ollama run phonon "Hello there" 31M / 40M ~0.1–0.15 GB Local text-to-speech in English, French, German, Spanish and Portuguese (Apple Silicon only)

Two other October trends matter. A new decision category of small models — Cloudflare’s clef, Perplexity’s pplx-decider, Liquid AI’s d1 and Together AI’s tev1 — scores, routes and classifies inputs instead of chatting. And several of the biggest additions are cloud-only: Mistral Large 4, DeepSeek V4.1 Flash, MiniMax M3.1 Flash, Muse Spark Open and Reflection’s Beam have only :cloud tags (for example ollama run mistral-large-4:cloud), so they run on Ollama’s servers rather than your machine — see our guide to Ollama cloud models. Workstation owners also got NVIDIA’s Nemotron 3.5 Super (nemotron-3.5-super:120b, ~80–90 GB). New models often need a recent Ollama release (Clef, for example, requires 0.35.1 or later), so update Ollama before pulling.

How to list the Ollama models you have installed

To see every model already on your machine, with its size and when it was last modified, run:

ollama list

That prints four columns: NAME (with the tag), ID, SIZE and MODIFIED. Ollama’s current CLI reference writes this command as ollama ls; both spellings work. To see what is loaded in memory right now use ollama ps, to unload one use ollama stop <name>, and to delete a model and reclaim its disk space use ollama rm <name> (step by step in how to remove an Ollama model). Those four commands are all you need to manage a local collection, and the full set is in our Ollama guide.

How to find and pull new models from the library

Ollama’s full catalogue lives in its online library, and pulling any model is one command:

ollama pull llama3.1  or run it directly with  ollama run llama3.1

Model names use tags for size and variant — llama3.1:8b, gemma4:26b, qwen3.5:27b. If you leave the tag off, Ollama pulls the model’s latest tag, and that size differs by family: plain gpt-oss is the 14 GB 20B, plain qwen3.6 is the 23 GB 35B and plain nemotron-3.5-bolt is the 25 GB 74B build, so check the model’s tags page first. Tags named cloud or ending in -cloud (such as kimi-k3.1-pro:cloud or deepseek-v4.1-flash:1017-cloud) run on Ollama’s servers instead of your machine, and -mlx tags are builds for Apple Silicon. For a first install, our step-by-step Ollama install guide covers Mac, Windows and Linux.

Small models — run on almost any laptop

Models from under 1B to about 4B parameters run happily on a modern laptop with 8 GB of RAM, no GPU required. Qwen 3.5 2B and 4B (which also read images), Llama 3.2 3B, Gemma 3 4B and Phi-3 Mini are the standouts, and Prism ML’s new Bonsai 2 fits a 9B model into a 3.2 GB download by using ternary weights. They are quick, genuinely useful for summarising, drafting and simple questions, and small enough to keep loaded. They will not match a frontier cloud model, but for private, offline everyday tasks they are excellent — and they are the right starting point if you are new to local AI.

Mid-size models — the 16 GB sweet spot

The 7B–14B class is where most people should live. Qwen 3.5 9B, Gemma 4 E4B and 12B and Llama 3.1 8B fit comfortably in 16 GB of RAM or a mainstream GPU, and the two newer families add image input and built-in thinking (reasoning) modes. OpenAI’s gpt-oss 20B (a 14 GB download) is the step up — Ollama says it runs on systems with as little as 16 GB of memory. Phi-4, Mistral Nemo and the older Qwen 2.5 7B and Mistral 7B remain solid options. If you want one model for general use, pick from this row — it is the best balance of capability and hardware demand.

Large models — workstation and GPU territory

From about 27B upwards you are into serious hardware. The current 26B–35B generation — Qwen 3.6 27B/35B, Qwen 3.8 27B, Gemma 4 26B and 31B, Meta’s Muse Glimmer 30B (ollama run muse-glimmer:30b, ~18 GB) and NVIDIA’s Nemotron 3.5 Lightning — downloads at roughly 16–25 GB and wants a 24 GB GPU or 32 GB+ of memory; older picks like Gemma 2 27B, Qwen 2.5 32B and Mixtral 8x7B sit in the same bracket. The 70B-and-up class — Llama 3.3 70B, the DeepSeek-R1 70B distill, gpt-oss 120B (65 GB, sized for a single 80 GB GPU), Qwen 3.5 122B (81 GB) and Meta’s Llama 4 Scout (llama4:scout, 67 GB) — needs 48 GB to 96 GB+ of fast memory, which in practice means high-VRAM GPUs or a high-memory Apple Silicon Mac. The reward is quality that approaches the big cloud models, running entirely on your own machine. See our best GPUs for AI guide for what actually runs these.

Specialised models: coding, vision and embeddings

Beyond general chat, Ollama hosts task-specific models. For coding, Qwen3-Coder 30B (qwen3-coder:30b, 19 GB), the -coding tags of Qwen 3.6 and the new Flint are built for agentic programming, while Qwen 2.5 Coder still covers small machines and Code Llama is the older option. For vision, Gemma 4 and Qwen 3.5 read images natively, Qwen3-VL (2B–235B) is the dedicated vision-language family, GLM-OCR (glm-ocr, 2.7 GB) handles document OCR, and LLaVA is the veteran. Embedding models like nomic-embed-text, mxbai-embed-large, Qwen3-Embedding and the multimodal EmbeddingGemma 2 do not chat at all — they turn text (and, for EmbeddingGemma 2, images; Google’s model card also lists video and audio) into vectors for search and retrieval-augmented generation, the backbone of a local RAG setup. Ollama now hosts text-to-speech too: Phonon reads text aloud in five languages on Apple Silicon Macs (speech generation arrived in Ollama 0.40.11), and Liquid AI’s lfm3-audio and lfm3-omni also speak on Linux and Windows.

Which Ollama model should you actually use?

The honest answer is: the largest one your memory can hold in the class you need. For general use, start with Qwen 3.5 9B or Gemma 4 E4B (or the long-proven Llama 3.1 8B) and move up only if quality falls short. For reasoning, try gpt-oss 20B or a DeepSeek-R1 distill; for coding, Qwen3-Coder 30B, or Qwen 2.5 Coder on smaller machines; for images, Gemma 4 or Qwen 3.5. We rank the best picks by use case in the best local LLMs to run on Ollama, and compare Ollama itself with the alternatives in Ollama vs LM Studio vs vLLM vs llama.cpp.

Check a model fits before you download

The single most common mistake is pulling a model too big for your machine — it will either refuse to load or crawl as it swaps to disk. Before downloading, size it up: as a rough rule a 4-bit model needs a little under 1 GB of memory per billion parameters, plus headroom for context. If you do not know how much memory your graphics card has, see how to check your VRAM. Our free VRAM calculator gives the exact figure for any model and quantisation, and Ollama’s system requirements explain the RAM-versus-VRAM trade-off in full.

Most models in this list are GGUF builds (the Apple-Silicon -mlx tags run on Ollama’s separate MLX engine); our GGUF models guide explains the quantization suffixes and which files fit your GPU.

More Ollama guides on Convly AI

Frequently asked questions

How do I list the models installed in Ollama? Run ollama list to see every installed model with its size, ollama ps for what is loaded now, and ollama rm <name> to delete one.

What is the best Ollama model? There is no single best — it depends on your memory. Llama 3.1 8B is still the most-pulled model in the library, but on a 16 GB machine the newer Qwen 3.5 9B and Gemma 4 E4B fit the same budget and add image input; see our ranked list for each use case.

How many models does Ollama have? 270 model families in the official library as of 7 November 2026 — chat, coding, vision, OCR, embedding, speech and the new decision models — most with several sizes and quantisations. The tables above cover the ones most people actually run.

What are the newest Ollama models? The early-November additions are Xiaomi’s MiMo V2.6 9B for code and agents (ollama run mimo-v2.6), the AutoTrust and pplx-decider-flash decision models and Kimi K3.1 Pro, which is cloud-only and runs on Ollama’s servers rather than your machine. Late October brought Liquid AI’s small LFM3 family (text, vision, audio and omni models), vLLM Semantic Router’s d3 decision models and Gradium’s Phonon text-to-speech. Other recent additions include NVIDIA’s Nemotron 3.5 Lightning and Bolt, Prism ML’s Bonsai 2, Recursive’s Flint and Google’s EmbeddingGemma 2. Among general chat families the latest are Qwen 3.8 (ollama run qwen3.8:27b), Qwen 3.6, Gemma 4 and Meta’s Muse Glimmer.

How much RAM do I need to run Ollama models? 8 GB runs small (1B–4B) models, 16 GB runs the popular 7B–12B class plus gpt-oss 20B, and a 24 GB GPU or 32 GB+ of memory is needed for 27B–35B models. Check any model with our VRAM calculator.

Can I run these models offline? Yes — once pulled, every local Ollama model runs entirely on your machine with no internet connection, which is the main reason to use local models at all. The exception is cloud-only tags named cloud or ending in -cloud, such as kimi-k3.1-pro:cloud: they run on Ollama’s servers, not on your machine, and need a connection.

The bottom line

The Ollama models list is long, but choosing is simple: decide what you need — general chat, reasoning, coding, vision or embeddings — then pick the biggest model in that family your memory can hold. Start small with an 8B model, use ollama list to keep track of what you have, and lean on the VRAM calculator before every download so you never pull something your machine cannot run. From there, running capable AI locally and privately is a couple of commands away.

Model names, sizes and availability change frequently; sizes and tags were checked against the official Ollama library on 7 November 2026 — verify with ollama list and the official library before relying on them.

Written by Mustafa Ihsan

Mustafa Ihsan is the founder and editor of Convly.ai. He built and maintains the site's live AI models database, its price-performance index, and its free calculators for VRAM requirements, API costs and self-hosting economics. He writes about model pricing, benchmark results and the hardware needed to run AI models locally, and consistently prefers measured numbers to vendor claims.

Scroll to Top