Updated 2026-11-02· 149 local models

GPU VRAM Calculator

Which local LLM fits on your graphics card, card by card: usable VRAM, the largest model each card holds, and the best pick with its estimated speed.

VRAM per billion params at Q4
~0.6 GB
Usable for weights
~90%
RTX 5080 weights
~14 GB
Cards, one row each
28

What can my GPU run? Weights at Q4 cost about 0.6 GB per billion parameters, against a usable budget of roughly 90% of your VRAM. On the RTX 5080 (16 GB, the calculator's default tier), that is ~14 GB of weights, which the engine pairs with Gemma 4 12B at est. 96 tok/s, typical error 15%. Every card below is graded the same way: VRAM fixes the ceiling, bandwidth sets the speed, and the table shows what each one actually fits.

Requirements calculator

GPU VRAM · 16 GB

Memory type
01

Memory.

Top pick
Gemma 4 12BGemma · top
Runs wellA · 44

Fits in 16 GB VRAM with room to spare. Best for chat, coding, multimodal on RTX 5080.

Footprint
8 GB
Speed
est. 96 tok/s typical error 15%
First token
~0.2s · Instant
Quant
Q4_K_M
Params
12B
registry-verified
Table 1Also fits
#ModelFitSizeLoad / 14 GBSpeedFirst token
2Qwen3.5 9B Instruct (Q8)QwenRuns wellB · 269B / Q8_010.7 GBest. 91 tok/stypical error 5%~0.9s · Instant
3Mellum2.1 12B-A2.5B ThinkingMellumRuns wellA · 4412.1B / Q4_K_M8.1 GBest. 235 tok/stypical error 15%~0.1s · Instant
4Gemma 4 12B (Q8)GemmaRuns wellB · 1112B / Q8_012.8 GBest. 61 tok/stypical error 15%~1.3s · Fast
5Gemma 4 E4B (Q8)GemmaRuns wellA · 484.5B / Q8_07.5 GBest. 141 tok/stypical error 5%~0.8s · Instant
6NVIDIA Nemotron 3.5 Bolt E4BNemotronRuns wellA · 454B / Q4_K_M7.9 GBest. 172 tok/stypical error 5%~0.2s · Instant
7Ministral 3 14BMistralRuns wellA · 3713.5B / Q4_K_M9.1 GBest. 84 tok/stypical error 15%~0.3s · Instant
8Qwen3.5 9B InstructQwenRuns wellA · 519B / Q4_K_M7 GBest. 140 tok/stypical error 5%~0.2s · Instant

Tokens/sec are ModelFit estimates from memory bandwidth and model size, not measured benchmarks. What typical error means. Ollama commands are registry-verified.

Table 2By card

Every card, what it fits

One row per discrete card in ModelFit's catalog, computed by the same engine the calculator runs: the 90% weights budget, then the largest and best-scoring local models that fit. The GPU hub lists the same cards side by side.

CardVRAMUsable for weightsLargest model that fitsBest pick
RTX 40608 GB~7 GBGLM-4-9B-Chat (9.4B)Ornith 1.0 9B est. 43 tok/stypical error 5%
RTX 306012 GB~11 GBMinistral 3 14B (13.5B)Mellum2.1 12B-A2.5B Thinking est. 98 tok/stypical error 15%
RTX 30708 GB~7 GBGLM-4-9B-Chat (9.4B)Ornith 1.0 9B est. 65 tok/stypical error 5%
RTX 4060 Ti16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Mellum2.1 12B-A2.5B Thinking est. 86 tok/stypical error 15%
RTX 5060 Ti16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 48 tok/stypical error 15%
RTX 3060 Ti8 GB~7 GBGLM-4-9B-Chat (9.4B)Ornith 1.0 9B est. 65 tok/stypical error 5%
RTX 20708 GB~7 GBGLM-4-9B-Chat (9.4B)Ornith 1.0 9B est. 58 tok/stypical error 5%
RTX 50608 GB~7 GBGLM-4-9B-Chat (9.4B)Ornith 1.0 9B est. 73 tok/stypical error 5%
RTX 407012 GB~11 GBMinistral 3 14B (13.5B)Qwen3.5 9B Instruct est. 78 tok/stypical error 5%
RTX 4070 SUPER12 GB~11 GBMinistral 3 14B (13.5B)Qwen3.5 9B Instruct est. 78 tok/stypical error 5%
RTX 507012 GB~11 GBMinistral 3 14B (13.5B)Gemma 4 12B est. 70 tok/stypical error 15%
RTX 5070 Ti16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 90 tok/stypical error 15%
RTX 4070 Ti SUPER16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 67 tok/stypical error 15%
RTX 4070 Ti12 GB~11 GBMinistral 3 14B (13.5B)Qwen3.5 9B Instruct est. 78 tok/stypical error 5%
Tesla P10016 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Mellum2.1 12B-A2.5B Thinking est. 84 tok/stypical error 15%
Tesla T416 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Mellum2.1 12B-A2.5B Thinking est. 75 tok/stypical error 15%
RTX 4080 SUPER16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 73 tok/stypical error 15%
RTX 508016 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 96 tok/stypical error 15%
RTX 309024 GB~22 GBQwen3.5 35B-A3B Instruct (35B, 3B active)Qwen3.8 27B est. 45 tok/stypical error 5%
RTX 409024 GB~22 GBQwen3.5 35B-A3B Instruct (35B, 3B active)Qwen3.8 27B est. 51 tok/stypical error 5%
RTX 408016 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 71 tok/stypical error 15%
RTX 3090 Ti24 GB~22 GBQwen3.5 35B-A3B Instruct (35B, 3B active)Qwen3.8 27B est. 48 tok/stypical error 5%
RTX 509032 GB~29 GBFlint 40B-A2.5B (39.8B, 2.5B active)Qwen3.8 27B est. 89 tok/stypical error 5%
RTX PRO 600096 GB~86 GBOrnith 1.5 122B (125.09B, 10B active)Kolibri 1 est. 282 tok/stypical error 15%
RX 7900 XTX24 GB~22 GBQwen3.5 35B-A3B Instruct (35B, 3B active)Qwen3.8 27B est. 44 tok/stypical error 50%
RX 7900 XT20 GB~18 GBMuse Glimmer 30B (29.8B)Qwen3.5 9B Instruct (Q8) est. 65 tok/stypical error 10%
RX 9070 XT16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Gemma 4 12B est. 58 tok/stypical error 10%
RX 9060 XT16 GB~14 GBLFM2 24B-A2B Instruct (24B, 2B active)Mellum2.1 12B-A2.5B Thinking est. 83 tok/stypical error 25%

Q4_K_M builds from ModelFit's 149-model catalog. Fit and tok/s are ModelFit estimates from memory bandwidth and model size, not measured benchmarks. Updated 2026-11-02.

Table 3Speed estimates

Speed by model size on three popular cards

These are estimates, not measured benchmarks: the bytes read per token over each card's own memory bandwidth, with efficiencies fitted on measured runs; a model fits when it stays within the 90% usable budget. Rows marked CPU offload exceed the card's VRAM; MoE rows scale by active parameters, so they degrade far less when offloaded.

Model sizeRTX 40608 GB · 272 GB/sRTX 409024 GB · 1008 GB/sRTX 509032 GB · 1792 GB/s
7Best. 46 tok/stypical error 5%Fits in VRAMest. 150 tok/stypical error 5%Fits in VRAMest. 237 tok/stypical error 5%Fits in VRAM
14Best. 5 tok/srough estimate, offload not measuredCPU offload (slow)est. 84 tok/stypical error 15%Fits in VRAMest. 141 tok/stypical error 15%Fits in VRAM
20B MoE (3.6B active)est. 19 tok/srough estimate, offload not measuredCPU offload (slow)est. 172 tok/stypical error 15%Fits in VRAMest. 265 tok/stypical error 15%Fits in VRAM
32Best. 1 tok/srough estimate, offload not measuredCPU offload (slow)est. 39 tok/stypical error 5%Fits in VRAMest. 69 tok/stypical error 5%Fits in VRAM
35B MoE (3B active)est. 23 tok/srough estimate, offload not measuredCPU offload (slow)est. 148 tok/srough estimate, offload not measuredCPU offload (slow)est. 297 tok/stypical error 15%Fits in VRAM
70Bnot practicalCPU offload (slow)est. 2 tok/srough estimate, offload not measuredCPU offload (slow)est. 3 tok/srough estimate, offload not measuredCPU offload (slow)
120B MoE (5.1B active)est. 14 tok/srough estimate, offload not measuredCPU offload (slow)est. 46 tok/srough estimate, offload not measuredCPU offload (slow)est. 73 tok/srough estimate, offload not measuredCPU offload (slow)

Decode speed of a generic Q4_K_M model of each size at 4K context; estimates, not measured benchmarks. Updated 2026-11-02.

Spec sheet

How to read your card's spec sheet

A graphics card spec sheet lists dozens of numbers, but two decide everything about local LLMs. VRAM is the hard ceiling: at Q4 the weights cost about 0.6 GB per billion parameters, and ModelFit budgets 90% of the card for them, which is why the table above rounds every card to its real usable budget. Memory bandwidth sets the speed once the model fits, because wider memory moves tokens out faster, and every tok/s figure on this page is an estimate scaled from it. Clock speeds and core counts move performance by a few percent; these two numbers decide whether the model runs at all and how it feels while it does.

FAQ

Frequently asked questions

Is 8GB of VRAM enough for local LLMs in 2026?

Eight gigabytes still covers the small-model tier. The 90% usable budget leaves about 7 GB for weights, which holds an 8B model at Q4 (5 GB) with modest context and powers lightweight chat and coding assistants; the RTX 4060 row of the table above shows exactly what the engine pairs with it. A 14B model needs about 8 GB of weights, so an 8GB card only reaches it with heavier quantization or CPU offload, both of which cost quality and speed. If 14B-class is your floor, a 12GB or 16GB card is the more comfortable starting point.

Does memory bandwidth matter as much as VRAM?

They answer different questions. VRAM decides what fits: nothing runs if the weights do not fit the budget. Bandwidth decides how fast it runs once it does, because decode speed is roughly proportional to it for a given model size, which is why every tok/s figure on this page starts from it (bytes read per token over bandwidth, with efficiencies fitted on measured runs). The practical consequence is that a faster older card with less VRAM can beat a roomier one on small models, so the best-pick column weighs fit first and speed second. Mixture-of-experts models bend the rule in your favor: only their active experts are read per token, so decode speed tracks active parameters, not the total.

Which GPU do I need for a 32B model?

A dense 32B at Q4 needs about 19 GB of weights, and against the 90% budget that implies a card with at least 22 GB of VRAM. In practice that means a 24GB card, such as the RTX 3090, RTX 4090 or RX 7900 XTX, which all hold it comfortably per the table above. A 16GB card lands at about 14 GB usable, roughly 5 GB short of a dense 32B, so it falls back to lower quantizations or CPU offload.

Can I pool two GPUs to run a bigger model?

Yes, and that is exactly what the multi-GPU rig mode of the calculator below computes. Two 16GB cards pool about 29 GB of usable weight budget, which clears the 19 GB a dense 32B needs. The honest caveat is that pooled throughput is lower than a single card with the same total VRAM, because layers are transferred between cards, and mixture-of-experts models tolerate pooling better since only their active experts cross the link. Pooling is the practical path to 70B-class models on consumer cards, which is why the rig mode exists.

Related tools

Go deeper