What local AI model can your PC run?
This page tells you what to run. You’ll need a free app to actually run it — see how do I run these? below.
No GPU · 8 GB RAM
Typical office laptop. Small models only — genuinely useful for questions, drafting and one-command-at-a-time help.
10–25 tokens/sec on a typical laptop CPU — faster than you can read.
The best small model of 2026: strong instruction-following and tool calling for its size.
Snappier than the 4B on weak or older CPUs.
Noticeably shallower answers — the escape hatch if the 4B feels sluggish.
Don’t — on 8 GB it swaps to disk and crawls well below reading speed.
The upgrade everyone tries first. Wait until you have 16 GB of RAM.
No GPU · 16 GB RAM
Most modern laptops without a gaming GPU. The 4B flies; a 9B becomes possible if you’re patient.
Reading speed or better, with enough RAM headroom to keep your browser open.
Start here. 256k context, handles follow-up questions well.
Similar speed to the Qwen 4B; more natural conversational tone, accepts image input.
Look for the ~5 GB Q4 build. Ollama’s 9.6 GB default is the same Q4 model — it just bundles the audio encoder in as well. Both work.
8–15 tokens/sec — roughly reading pace, and noticeably smarter answers than the 4B.
Use when quality matters more than speed.
No GPU · 32 GB+ RAM
Desktop-class RAM without a real GPU. Mixture-of-experts models change the math here — big brains, small per-word cost.
Roughly 13–18 tokens/sec once it gets going — a little quicker than you read — but with no graphics card, long questions can sit a while before the first word appears.
A 24 GB model in 32 GB of RAM leaves little spare, so keep your questions and context modest. The one MoE experiment genuinely worth trying without a GPU.
Comfortable at this RAM level — the reliable pick.
The safe choice while the MoE experiments shake out.
4–6 GB GPU
Entry gaming laptops and older cards (GTX 1650/1060, RTX 3050). Small models feel instant here — but check each pick against your card: 4 GB fits the 4B, not the 5 GB Gemma.
25–40 tokens/sec fully on the GPU — feels instant.
Fits entirely in VRAM with room for context.
Fast and personable; image input included.
The ~5 GB Q4 build is the plain text-and-image one; a 9.6 GB version of the same model bundles the audio encoder too. Needs a 6 GB card.
8 GB GPU
The most common gaming card class (RTX 3060 Ti/4060, RX 6600). A 9B model fits fully and flies.
Fast — the model itself fits on the card, though a large context window will push you over.
The sweet-spot model for this card class.
Instant-feeling; handles images too.
Runs alongside other GPU apps comfortably at this size.
10–12 GB GPU
RTX 3060 12GB / 4070 class — a small card that punches far above its weight.
Usable, and how usable depends far more on your setup than your card — published results for this exact combination disagree by more than double, so treat any single number you read with suspicion.
Needs 32 GB system RAM. It has to split across GPU and RAM, and the expert-offload setting that makes that fast isn’t available in every app — that’s the variable that decides your speed.
Watchable rather than snappy — this one also splits across GPU and RAM, so expect slow going on long multi-step agent runs.
An older but still-reliable coding pick — newer models beat it now, but it needs no special configuration to behave.
Very fast — the whole model fits in VRAM, so nothing spills to system RAM.
The zero-fuss pick: no splitting, no extra configuration, and room left over for a large context window. Try this before the bigger two.
16 GB GPU
RTX 4080 / 4070 Ti Super class. 27B-class models come into range.
Quick on a 16 GB card — comfortably faster than you can read.
Compressed to fit a 16 GB card. Go no lower than 4-bit here — 3-bit builds are smaller, but they measurably degrade the reasoning and tool-calling this pick is here for.
Fast — still splits across GPU and RAM, but far less spilling than on a 12 GB card.
Needs 32 GB system RAM for the offloaded experts.
Fully on GPU, quick and personable.
The everyday pick when you’re not doing agent work.
24 GB GPU
RTX 3090/4090 class. The best local coding models run fully on GPU — no compromises.
Fast, fully on GPU, big context headroom.
Widely rated the best local agentic coder of mid-2026.
The standard Q4 build is ~24 GB and won’t quite fit a 24 GB card — a ~22 GB build does, with little room left for context.
MoE speed without the offload tricks.
Around 128 tokens/sec measured on an RTX 3090 — roughly three times a dense 27B, and about on par with the 35B-A3B rather than clearly ahead of it.
Excellent for everyday chat, images and simple tool use, and it leaves ~6 GB of the card free. For multi-step agent work the Qwen picks on this tier are markedly more reliable.
32 GB+ GPU / multi-GPU
Workstation territory (RTX 5090, dual cards). Higher-precision builds of the best models.
Comfortably quicker than you can read, with noticeably fewer of the small slips 4-bit builds make.
Q6 is 22.5 GB and Q8 is 28.6 GB — both fit a 32 GB card, and Q6 leaves real room for a big context window.
Apple Silicon · 16 GB unified
M-series Macs share memory between CPU and GPU, so your RAM largely doubles as your VRAM (macOS reserves a slice for itself). Look for MLX builds — they’re tuned for Apple Silicon.
Fast on any M-series chip.
MLX builds are optimized for Apple Silicon — prefer them over GGUF.
Instant-feeling.
Leaves plenty of memory for your actual work.
Apple Silicon · 32 GB unified
M-series Pro class. MoE models love unified memory — no GPU/RAM split to manage at all.
Fast — the whole model sits in unified memory.
The standout pick for 32 GB Macs.
Solid speed, proven quality.
The alternative if you prefer steady, predictable memory use.
Apple Silicon · 64 GB unified
M-series Max class. High-precision 27B builds and fast MoE — a serious local AI workstation.
Fast and precise.
Room for huge context windows at this memory level.
Extremely quick.
The speed pick.
Apple Silicon · 128 GB+ unified
128 GB of unified memory (M-series Max or Ultra). Frontier-adjacent models at home.
Around 40 tokens/sec measured on an M3 Max — genuinely fast for a model this size, and higher on Ultra chips.
The 4-bit build is ~70 GB and uses 72–76 GB in practice, so 128 GB of memory is the real requirement, not an Ultra chip. Skip the 8-bit build — it doesn’t fit.
Changelog
- 2026-07-20 — Units fixed: speeds were labelled “words/sec” but every source measures tokens per second (a token is about ¾ of a word), which overstated every figure by roughly a third. All speeds are now labelled tokens/sec, and the “reading speed” comparisons were re-anchored — they previously called 10–25 and 8–15 both “reading speed” and “a word at a time”.
- 2026-07-20 — All provisional picks resolved. Gemma 4 26B-A4B on a 24 GB card moves up to “worth your time” — measured at ~128 tokens/sec on an RTX 3090, about three times a dense 27B (the old note calling it slower rested on no measurement). Corrected: that 3x is against the dense 27B, not the 35B-A3B MoE, which measures about level with it.
- 2026-07-20 — Sourcing rule: where this page gives a number it now comes from a measured run on real hardware, never a VRAM-calculator estimate — one such site put an RTX 3060 at 4.7 tokens/sec where hands-on tests measured several times that. Where published results genuinely disagree, we now say so instead of picking one: the 10–12 GB MoE pick is the current example.
- 2026-07-20 — Corrections found in review: Gemma 4 E4B is ~5 GB at Q4 (the ~3.5 GB file is a 2-bit build), Gemma 4 26B-A4B is ~18 GB at Q4, the 16 GB pick now points at a 4-bit build rather than 3-bit (3-bit measurably hurts tool-calling), and the 128 GB Mac pick is Qwen3.5 122B-A10B — Qwen3.6 never shipped that size.
- 2026-07-20 — Scope: this page answers what your PC can run, not how to install it. Removed the app-specific run commands — they assumed you already knew the tool, and they went stale fastest.
- 2026-07-20 — Accuracy: corrected the 10–12 GB tier. The LM Studio expert-offload toggle it referenced was replaced by a different control in LM Studio 0.4.0, and the quoted 33–36 tokens/sec figure was measured with llama.cpp rather than the app it was credited to. Speed claims for models that split across GPU and RAM are qualitative until re-measured.
- 2026-07-13 — Initial version, seeded from the July 2026 research pass.
- 2026-07-13 — Review pass: filter now checks your RAM against each pick (with warnings), honest below-minimum guidance, dedicated-vs-shared GPU memory clarified, clearer run commands.
How this list works: curated picks per hardware tier — not every model that exists. “Worth your time” means it runs at a speed and quality that won’t make you regret the download. The bar on each card shows the model’s download size against your tier’s memory. Speeds are given in tokens per second — a token is roughly ¾ of a word, so 40 tokens/sec is about 30 words a second, far quicker than you read. Where we give a number it comes from a measured run on real hardware — a hands-on report or published benchmark, never a VRAM-calculator estimate, which gets these models badly wrong. Where we don’t have a solid measurement, or where published results genuinely disagree, we say “fast” or “slow” and leave it at that rather than pick a number. Speeds are indicative, not promises: the app you use and how you configure it can move them a lot, especially for models that split across GPU and RAM. Picks are reviewed on a schedule as new models release — see the changelog. Sizes are the standard (Q4) build unless noted: Q4/Q6/Q8 are compression levels (higher = bigger but slightly sharper). “MoE” models activate only a small part of themselves per word — that’s why some huge ones run on modest hardware. Why mostly Qwen and Gemma right now? They currently lead open-model quality per gigabyte at these sizes — the picks change when the data does.
How do I actually run these?
A model is just a file — you need a free app to load it and talk to it. Two worth knowing, both free, both Windows/Mac/Linux:
- Ollama — ships a simple chat app on Windows and Mac, plus a terminal command if you prefer it (on Linux it’s terminal-only). Easiest to point other tools at.
- LM Studio — a normal app with a window. Search and download models from Hugging Face in-app, then chat right there.
Either will run most of the picks above, and for anything that fits entirely in your memory the choice is down to taste. One exception worth knowing: the big “MoE” picks that have to split across GPU and RAM lean on an expert-offload setting. LM Studio exposes it as an “n_cpu_moe” slider; Ollama currently doesn’t expose it at all. If a split pick runs badly, that’s usually why — and the fastest published numbers for those models come from llama.cpp directly, the engine underneath both apps, which gives you unrestricted control.
Ollama is free and open source; running models locally is unlimited (its paid tiers are for their cloud models). LM Studio is free for home and work use, though it isn’t open source.