Numbers below are as published on AI Model Radar on 16 September 2026, for the 46 open-weights models we track. Everything is recomputable from public files; nothing is a benchmark.
The most common question under any model release is “will this run on my card?”, and the most common answers are folklore: “about four gigabytes per billion parameters”, “add twenty percent for context”, “a 12 GB card runs 13B”. Those rules were roughly right in 2023. For the models shipping now they can be off by a factor of four, and for one family by forty.
We run a small site that answers the question with arithmetic from published facts, and this post shows the arithmetic, because the interesting part is where the old rules break.
Whether a model fits a card comes down to three quantities and one margin.
config.json: how many layers cache the context, how many key-value heads they have, how wide each head is, how many tokens you allow. This is the number the folklore gets wrong.
The sum has to fit into the usable memory of the card: we keep 12 % of a graphics card as a safety margin, and we plan Apple Silicon at 70 % of unified memory, because macOS caps how much of the pool the GPU may wire down (the kernel default is two thirds of RAM up to 32 GB, three quarters above).
That is the whole engine. Weights are a fact you can check before down. The cache is arithmetic. The margin is a stated assumption you can disagree with.
The classic context-cache formula is simple:
bytes = 2 × layers × kv_heads × head_dim × tokens × bytes_per_value
Two for keys and values, times every layer, times the shape of one head, times the tokens, times two bytes for f16. Three things about current models make that formula misleading if you apply it naively.
Not every layer caches the whole context any more. Hybrid attention has become the norm. A config.json now often carries a layer_types array, and the layers behave differently:
| Model | Layers | Layers that cache the full context | The rest |
|---|---|---|---|
| Gemma 3 27B | 62 | 10 | 52 sliding-window layers capped at 1,024 tokens |
| Gemma 4 12B | 48 | 8 | 40 sliding-window layers, 1,024 tokens |
| Qwen3.8 27B | 64 | 16 | 48 linear-attention layers with a constant state |
| gpt-oss 20B | 24 | 12 | 12 sliding-window layers, 128 tokens |
Gemma 3 27B at 32K tokens needs about 2.9 GB of context cache, not the 15 GB the every-layer formula gives. Qwen3.8 27B needs 2.0 GB where the formula says 8. If you assume every layer caches everything, you will tell people a card is too small when it is not.
MLA models store one latent, not keys and values. DeepSeek-V4 and the GLM-5 family use multi-head latent attention: each layer keeps a single compressed vector per token (576 dimensions in every MLA model we have measured so far) instead of separate K and V tensors. There is no factor of two, and the head shape does not enter at all. Applied naively, the classic formula overstates GLM-5.2’s cache at 128K context by roughly forty times, hundreds of gigabytes instead of about eleven. That single mistake turns a model that fits a large unified-memory machine into one that “needs a data centre”.
The head dimension has to be read, not derived. The common shortcut hidden_size / num_attention_heads is wrong for five of the first eight models we curated; they publish head_dim explicitly and it is 128, not what the division gives. One model, GLM-4.7-Flash, returns 102.4 from the division, which is not a dimension any tensor has. When a config does not let us derive the shape, we say unknown rather than round.
Take the RTX 3060 12 GB, still the most common “budget local AI” card. With the 12 % margin it has 10.6 GB usable. Here is what the arithmetic says for a few of the models people actually ask about, at 8K and at 32K tokens of context, f16 cache, Q4_K_M weights:
| Model (Q4_K_M) | Weights | Cache at 8K | Total at 8K | Verdict | Cache at 32K | Total at 32K | Verdict |
|---|---|---|---|---|---|---|---|
| Phi-4 Mini | 2.3 GB | 1.0 GB | 4.2 GB | excellent | 4.0 GB | 8.0 GB | good |
| Qwen3 8B | 4.7 GB | 1.1 GB | 6.8 GB | excellent | 4.5 GB | 10.9 GB | offload |
| Gemma 4 12B | 6.6 GB | 0.8 GB | 8.5 GB | good | 2.3 GB | 10.7 GB | offload |
| Qwen3 14B | 8.4 GB | 1.3 GB | 10.8 GB | offload | 5.0 GB | 15.3 GB | offload |
| gpt-oss 20B | 10.8 GB | 0.2 GB | 12.2 GB | offload | 0.8 GB | 13.5 GB | offload |
| Gemma 3 27B | 15.4 GB | 1.0 GB | 17.7 GB | offload | 2.9 GB | 20.4 GB | offload |
Three things in that table are worth reading twice.
Across all 46 tracked models, the 12 GB card runs 14 comfortably at 8K and 10 at 32K. An RTX 4090 with 21.1 GB usable runs 22 at 8K and 16 at 32K. A Mac mini M4 Pro with 64 GB of unified memory, planned at 44.8 GB, runs 29 at 32K. Two models are “unknown” on every machine, because their configs are gated and we do not guess.
Every number on the site carries either a collection timestamp, a source link, or a stated assumption you can change. If a config file says something different from what we computed, we would rather be corrected than believed.
The same engine can be pointed at any machine, so we did that for fun with old cards. A GeForce GTX 980 from 2014, with 4 GB, runs 3 of today’s 46 tracked models comfortably at 8K. A GeForce 256 from 1999, with 32 MB, runs none: the smallest tracked model needs 1.7 GB, about sixty times what the card can give it. A DGX Spark with 128 GB of unified memory runs 34. Thirty years of hardware, one memory formula.
GET https://aimodelradar.dev/api/v1/fit?hardware=rtx-3060-12gb&context=32768
If your card is not in the list, or a model’s shape looks wrong to you, say so. The catalog is curated by hand and every correction that survives checking changes the data.