LLM Hardware Requirements Calculator
ModelFit is a free tool that tells you which local AI models run on your hardware. Enter your RAM or GPU VRAM and see exactly which local AI models you can run, the single best pick, and how fast it will go.
- Memory per billion params at Q4
- ~0.6 GB
- Unified memory budget
- 70 to 85%
- Usable GPU VRAM
- ~90%
- 16 GB comfortably runs
- ~14B
- 64 GB or more runs
- 70B-class
What LLM can I run? A local model at Q4 quantization needs roughly 0.6 GB of memory per billion parameters. ModelFit budgets about 70% of unified memory for the model on machines up to 32GB, scaling to ~85% at 128GB and above, and about 90% of a discrete GPU's VRAM. That means an 8GB device runs models up to ~9B, a 16GB device comfortably runs up to ~14B, 32GB unlocks ~32B-class models, and 64GB or more runs 70B-class models. Use the calculator below to size your exact hardware against 147 local models.
Requirements calculator
Memory.
Fits in 8 GB VRAM with room to spare. Best for agentic coding on small machines on RTX 4060.
- Footprint
- 5.6 GB
- Speed
- est. 43 tok/s typical error 5%
- First token
- ~0.6s · Instant
- Quant
- Q4_K_M
- Params
- 9B
| # | Model | Fit | Size | Load / 7 GB | Speed | First token |
|---|---|---|---|---|---|---|
| 2 | LFM2.5 8B-A1BLFM2 | Runs wellB · 24 | 8.3B / Q4_K_M | 5.5 GB | est. 118 tok/stypical error 15% | ~0.1s · Instant |
| 3 | Qwen3.5 4B Instruct (Q8)Qwen | Runs wellA · 40 | 4B / Q8_0 | 4.3 GB | est. 47 tok/stypical error 5% | ~1.6s · Fast |
| 4 | Gemma 4 E4BGemma | Runs wellA · 44 | 4.5B / Q4_K_M | 4 GB | est. 61 tok/stypical error 5% | ~0.5s · Instant |
| 5 | MiMo-V2.6-Distill-Qwen-9BMiMo | Runs wellB · 19 | 9B / Q4_K_M | 5.8 GB | est. 42 tok/stypical error 5% | ~0.6s · Instant |
| 6 | Gemma 4 E2B (Q8)Gemma | Runs wellA · 36 | 2.3B / Q8_0 | 4.6 GB | est. 97 tok/stypical error 5% | ~1.6s · Fast |
| 7 | Qwen3.5 9B InstructQwen | Runs wellB · 3 | 9B / Q4_K_M | 7 GB | est. 43 tok/stypical error 5% | ~0.6s · Instant |
| 8 | Granite 4.2 8BGranite | Runs wellA · 31 | 8.8B / Q4_K_M | 5 GB | est. 38 tok/stypical error 5% | ~0.6s · Instant |
Tokens/sec are ModelFit estimates from memory bandwidth and model size, not measured benchmarks. What typical error means. Ollama commands are registry-verified.
Local LLM memory requirements by RAM tier
Every row is derived from ModelFit's catalog of 147 local models across 35 families. Click a tier for the full list.
| Memory | Model budget (~70-85%) | Max dense model size | Models that fit | Top pick |
|---|---|---|---|---|
| 8 GB | ~5.6 GB | ~9B params | 34 / 147 | Qwen3.5 4B Instruct |
| 16 GB | ~11.2 GB | ~14B params | 65 / 147 | Qwen3.5 9B Instruct |
| 24 GB | ~16.8 GB | ~29.3B params | 80 / 147 | LFM2 24B-A2B Instruct |
| 32 GB | ~22.4 GB | ~32B params | 102 / 147 | Gemma 4 26B-A4B |
| 48 GB | ~34.8 GB | ~32B params | 117 / 147 | Qwen3.6 35B-A3B |
| 64 GB | ~48 GB | ~70B params | 124 / 147 | Nemotron 3.5 Lightning 30B-A3B |
| 96 GB | ~76.8 GB | ~123B params | 135 / 147 | Kolibri 1 |
| 128 GB | ~108.8 GB | ~123B params | 141 / 147 | Qwen3.5 122B-A10B Instruct |
Q4_K_M assumed. Fit and tok/s are ModelFit estimates from the dataset, not measured benchmarks. Updated 2026-10-31.
What each memory tier adds
Each card leads with the models that tier unlocks over the tier below, then the best models that already fit, all from the same 147-model catalog as the calculator above. Every model name links to its own memory math.
8 GB
34 of 147 models fit~5.6 GB usable for weights · everything that fits starts here
16 GB
65 of 147 models fit~11.2 GB usable for weights · 5 newly unlocked over 5.6 GB
24 GB
80 of 147 models fit~16.8 GB usable for weights · 5 newly unlocked over 11.2 GB
32 GB
102 of 147 models fit~22.4 GB usable for weights · 5 newly unlocked over 16.8 GB
48 GB
117 of 147 models fit~34.8 GB usable for weights · 5 newly unlocked over 22.4 GB
64 GB
124 of 147 models fit~48 GB usable for weights · 5 newly unlocked over 34.8 GB
96 GB
135 of 147 models fit~76.8 GB usable for weights · 5 newly unlocked over 48 GB
128 GB
141 of 147 models fit~108.8 GB usable for weights · 5 newly unlocked over 76.8 GB
Loads are Q4_K_M estimates including weights only; context and KV-cache need headroom on top. Click a tier for the full ranked list, or a model name for its per-hardware fit math.
Get told when a better model fits your MacBook Air M5 16 GB
Get one email when a new open-weight model is a better fit for this machine.
For: MacBook Air M5 16 GB
You'll also get the weekly ModelFit email. By signing up you agree to our Privacy Policy. Unsubscribe from either email anytime, in one click.
Frequently asked questions
How much RAM do I need to run a local LLM?
At Q4 quantization a local LLM needs roughly 0.6 GB of memory per billion parameters, and ModelFit budgets ~70% of unified memory for the model up to 32GB, scaling to ~85% at 128GB and above. In practice 8GB runs models up to ~9B, 16GB comfortably runs up to ~14B, 32GB unlocks ~32B-class models, and 64GB or more runs 70B-class models.
What LLM can I run with my GPU VRAM?
VRAM is the hard ceiling for a discrete GPU, and about 90% of it is usable for model weights. On the engine's reference card for each size, 8GB runs dense models up to ~9B, 12GB up to ~14B, 16GB up to ~14B (or a ~24B mixture-of-experts model), 24GB up to ~32B (or a ~35B mixture-of-experts model) and 32GB up to ~32B (or a ~40B mixture-of-experts model) at Q4. Switch the calculator to GPU VRAM mode and enter your card memory to see the exact picks.
How does the calculator work?
Enter your memory amount and pick Apple unified memory or GPU VRAM. The calculator runs ModelFit’s recommendation engine in your browser: it sizes each model at ~0.6 GB per billion parameters, applies the memory budget for your hardware, and ranks the models that fit by quality and speed. A shared link carries its configuration in the URL, and that configuration is rendered on the server first, so /calculator/?gb=32 already shows the 32 GB picks before any JavaScript runs. Tokens per second are ModelFit estimates from memory bandwidth and model size, not measured benchmarks.
Can I combine two GPUs to run bigger local models?
Yes. Ollama and llama.cpp split model layers across cards automatically, so two or three GPUs pool their VRAM for fit: about 90% of the combined VRAM is usable for weights. Expect real throughput below a single card with the same total VRAM, because inter-GPU transfers add overhead and mixed cards run at the slower card’s pace. Switch the calculator to Multi-GPU rig mode to pick your exact cards and see which models fit, and use the Copy link button to share the setup.
Is the ModelFit calculator free?
Yes. The calculator is completely free, needs no sign-up, and runs entirely in your browser with no data sent to a server. The underlying compatibility dataset is open under CC BY 4.0, and the same engine ships as the free npx @modelfit/cli@latest command-line tool.
Go deeper
- VRAM calculatorPer-card picks, plus what long context costs on a discrete GPU.
- LLM memory calculatorThe memory arithmetic: weights, KV cache, and the usable budget.
- GPU VRAM calculatorCard by card: what each GPU holds, its largest model, its best pick.
- VRAM per model sizeReal GGUF sizes from 1B to 80B, and the smallest card that fits each.
- Best LLM by VRAMThe engine's pick for 8, 12, 16, 24 GB cards, with every card of each size.
- RAM vs VRAM for LLMsApple unified memory against a discrete GPU, tier by tier.
- Device wizardPick your exact MacBook, iPhone or GPU for a tuned recommendation.
- Full compatibility matrixEvery model against every hardware tier, open under CC BY 4.0.
- How much RAM do you need?The model-size-to-memory matrix explained, tier by tier.
- Hardware statsCitable key facts on RAM, VRAM and model fit.
The same engine runs offline as a one-line command that detects your machine and names the best local model:
npx @modelfit/cli@latest