What actually runs on your GPU in 2026 — the honest table

Ask what GPU you need for local AI and most answers arrive shaped like an upsell. This page is the other kind of answer. We track 83 open-weight models that people actually download from Hugging Face — not models that merely exist — and we size them with the same rule that drives the calculator on our local AI page. What follows is that catalogue sorted by the card you already own, with the uncertainty printed in the same font size as the claims.

The rule we size with

The estimate is one line long: VRAM required ≈ 0.58 GB per billion parameters, plus the KV cache, plus 0.8 GB of margin. On Apple Silicon, count 70 % of the unified RAM as available to the model. That is the whole formula, and it assumes the compact quantised builds people actually run — more on that below.

With the rule stated, the rest is arithmetic-free reading: here is what lands where.

The honest table

The same shelf, arranged by the budget on your card:

A dash means we do not have a download count we trust for that entry, so we print none. The pattern in the last column is worth a pause before we walk the tiers, because it is the opposite of what the hardware discourse suggests: the heaviest download traffic sits in the smallest tier, and nothing further down the table comes close to it.

8 GB: the card most people already own

The entry tier is where the crowd is. Qwen3 8B lands at an estimated 6.4 GB and carries 16,046,227 Hugging Face downloads — the heaviest traffic of any model in the table above. Llama 3.1 8B Instruct needs the same estimated 6.4 GB and has 7,461,917 downloads of its own. Ornith 1.0 9B asks slightly more, an estimated 7.0 GB, and still shows 2,463,295 downloads.

None of this requires a workstation. It requires the memory found on an ordinary mid-range gaming card, or a modest slice of unified RAM on a laptop. The practical reading: if your card has 8 GB, you are not window-shopping — you are choosing between the most-used local models in existence.

12–16 GB: the 14B class, three ways

The middle tier currently belongs to one family. Qwen2.5 14B Instruct (3,066,555 downloads), Qwen2.5 Coder 14B Instruct (2,415,331) and the newer Qwen3 14B (2,271,204) all carry the same estimate: 10.2 GB. The choice between them is a choice of purpose, not of size — the Coder variant exists for exactly the reason its name suggests, and the leaderboard is the quickest way to see how the general-purpose two stack up.

One habit worth keeping at this tier and every other: before you commit a project to a model, check that its upstream is still alive. Our study of how much open-source AI is quietly abandoned is the uncomfortable companion piece to every sizing guide, including this one.

24 GB and 48 GB: where big models become residents

24 GB is the headline tier of this article, and the reason is a single row of the table: Ornith 1.0 35B, estimated at 23.0 GB, fits. Inside the budget, with little room to spare — and its 3,211,614 downloads say this is a mainstream practice, not a stunt. Yi 34B sits just under it at an estimated 22.4 GB. A 35B-class model resident on a single consumer card is the quiet milestone of local AI in 2026.

At 48 GB the 70B class opens. Qwen 72B is estimated at 45.2 GB and shows 2,671,966 downloads; Llama 3.3 70B Instruct is estimated at 44.0 GB. Note how close both sit to the ceiling: at this tier the ±40 % margin stops being a footnote and becomes the whole question. Run the numbers for your exact card and context length in the calculator before buying anything, and check where these models actually rank on the leaderboard before assuming bigger means better for your task.

What the download counts actually say

Here is the fact that reframes the whole table. The most downloaded open-weight model in our catalogue is not any of the flagships above. It is Qwen3 0.6B, at 29,244,641 downloads — a model so small that VRAM budgeting is beside the point.

The lesson: the volume is in the small models. The centre of gravity of local AI is not the biggest model your card can hold; it is the smallest model that does the job, pulled millions of times into pipelines, edge devices and experiments. Hardware discourse runs on envy, but usage runs on sufficiency.

That framing matters for money, too. Whether running locally beats paying for an API depends on which class of model your task really needs — and the pricing side of that decision is mapped in our analysis of the price gap between open and closed models.

A word on quantisation — without fake precision

Every estimate above assumes the compact quantised builds that people actually download and run; that is what the rule was fitted to. Push quantisation harder and the requirements drop further — models slide down a tier, sometimes two. We are deliberately not printing figures for that here, because the honest answer is that it depends on the build, the runtime and how much quality loss your task tolerates. The rule of thumb plus its ±40 % margin already brackets most of it.

And once a model is resident on your card, the interesting question stops being does it fit and becomes what can it reach. That layer — the tools and servers a local model can plug into — is charted in our map of the MCP ecosystem.

Keep reading

• How much open-source AI is already abandoned — the maintenance reality behind the models you are about to depend on.
• The real price gap between open and closed models — the other half of the local-versus-API decision.
• The MCP ecosystem, mapped — what your local model can connect to once it runs.

Data: olud.ai catalogue, refreshed nightly — sizing rule published on /local-ai.html.