RTX 4080 SUPER

An RTX 4080 SUPER runs 12 of the 34 open models tracked here at Q4_K_M with 8k context, computed on 16 October 2026. The largest is gpt-oss 20B, needing 13.4 GB and generating at most 247 tokens per second.

Updated

Memory
16 GB VRAM
Bandwidth
736 GB/s
Board power
320 W
Released
2024
Availability
Mostly second-hand
What it runs
12 of 34 models
At Q4_K_M with 8k context. The largest it holds is gpt-oss 20B: 13.4 GB, at most 247 tokens per second.
Computed 16 October 2026
Best model to run
Gemma 4 12B
8.2 GB of 16 GB, about 74 tokens per second: faster than you can read. Picked as the biggest class of model that fits with room to spare and answers at 25 tokens per second or faster, then the newest release in it.
Computed 16 October 2026

Open the RTX 4080 SUPER in the LLM checker

What an RTX 4080 SUPER runs, model by model

RTX 4080 SUPER (16 GB) addresses 16 GB at 736 GB/s. Every model below is at Q4_K_M with 8k of context, the setting most people actually use. Once the 5% safety margin comes off, the card has 15.2 GB to spend: memory decides what loads, bandwidth how fast it answers. Both are estimates from stated formulas, and the VRAM calculator shows the working.

On this card a model fits at or under 15.2 GB, and above 13.6 GB it is tight: it loads, but there is little left for the conversation, and a desktop on the same 16 GB can push it over. Tokens per second are single-stream estimates from memory bandwidth; ≤ marks a ceiling real runtimes fall well below.

Computed 16 October 2026

The model to actually run on it

Gemma 4 12B is the best use of this card: 8.2 GB of the 16 GB available, an estimated 74 tokens per second, faster than you can read, and 131,072 tokens of context still available.

How this is chosen, since no benchmark is quoted: models are compared by size, a mixture-of-experts model counting at the geometric mean of its total and active parameters (a rule of thumb, not a measurement). The pick is the biggest class that fits with memory to spare and answers at 25 tokens per second or better, and within that class the most recent general-purpose release; coding and reasoning specialists are listed above but not recommended by default.

gpt-oss 20B is the largest model the card will hold, at 13.4 GB, with room for 81,920 tokens of context. It is a mixture-of-experts model reading only 3.6B parameters per token, so it is the faster of the two at an estimated 247 tokens per second; what it gives up is the depth of a dense model that reads all of its weights for every token.

It also fits at Q8_0, in about 14.2 GB, which is worth taking whenever the memory allows: Q8 is near-lossless where Q4 costs a little accuracy.

How much context actually fits

Model size is the question people ask; context is the one that bites. The KV cache grows linearly with the conversation, so a model that loads comfortably can still run out of memory halfway through a long document. On 16 GB, the context you get is whatever the weights leave behind, which is why two cards that run the same model can feel completely different in use. These are the largest contexts this card holds, at Q4_K_M weights.

ModelMax context, FP16 KVWith Q8 KV cache
Gemma 4 12B 131,072 tokens 131,072 tokens
Qwen3 14B 34,816 tokens 40,960 tokens · model limit
Phi-4 14B 16,384 tokens · model limit 16,384 tokens · model limit
Ministral 3 14B 37,888 tokens 75,776 tokens

Quantising the KV cache to Q8 roughly doubles what you can hold, at a quality cost most people never notice: Ministral 3 14B on this card goes from 37,888 to 75,776 tokens. Capped at 128k tokens, or at the model's own native window where that is smaller, marked "model limit": free memory beyond that point buys nothing. Rows that hold far more context than their size suggests are hybrid, sliding-window or latent-attention models, which cache only a fraction of what a standard transformer does; each model page shows the working.

Computed 16 October 2026

Where this card stops

The first model out of reach is Devstral Small 2 24B: about 16.3 GB at Q4_K_M and 8k context, against 16 GB of usable memory. Dropping to Q3_K_M would need about 13.6 GB, which fits, though Q3 loses enough quality that a smaller model at Q4 is usually the better trade. Offloading the remainder to system RAM works and is ten to fifty times slower; it is a way to see a model run, not a way to use one.

Buy or rent

Do not buy one for language models: a used 3090 holds more and reads it faster, and the newer 5070 Ti reads the same 16 GB about a fifth faster. If you already own one, it is a capable 16 GB card; rent a larger card for the models it cannot hold.

Second-hand pricing is the whole argument for this card, and it moves week to week, so printing a number here would be worse than printing none. Put the figure you are actually looking at, with your electricity rate and your real monthly hours, into the build vs rent calculator, which already knows this card draws 320 W under load. It returns the month owning becomes cheaper, or tells you it never does. Hours per month decides it far more often than the price does.

The honest take

A 16 GB gaming card that a used 3090 beats on both numbers that matter for language models.

Sixteen gigabytes on a 256-bit bus, read at 736 GB/s. Both figures sit below a used 3090 (24 GB at 936 GB/s), so for local models it holds less and generates more slowly than an older card. It is an Ada card, so FP8 runs natively but FP4 does not. The newer 5080 and 5070 Ti keep the 16 GB and read it faster.

What it is good at

  • 736 GB/s is quick for anything that fits in 16 GB.
  • Ada generation: FP8 formats run natively.
  • A mature card: every current runtime supports it, with none of a new generation's rough edges.

What it is not

  • Less memory and less bandwidth than a used 3090: 16 GB against 24 GB, and the 3090 reads about 27% faster.
  • No FP4: that arrived with Blackwell.
  • The Founders Edition is a three-slot, 320 W card.

The thing people get wrong: Newer is not better here. Against a used 3090 the 4080 SUPER loses on both numbers that matter for language models: 16 GB against 24 GB, and 736 GB/s against 936 GB/s. Its advantages, Ada compute and FP8, show in image generation and prompt processing, not in what fits or how fast it is read.

Compared with the alternatives

  • RTX 3090: 24 GB · 936 GB/s · best fit Muse Glimmer 30B at ~38 tok/s. The value benchmark for local models, and it has been for years.
  • RTX 5080: 16 GB · 960 GB/s · best fit Gemma 4 12B at ~97 tok/s. A 16 GB card with 3090-class bandwidth: quick on what fits, and it fits no more than a 5060 Ti 16 GB.
  • RTX 5070 Ti: 16 GB · 896 GB/s · best fit Gemma 4 12B at ~90 tok/s. The 5080's memory bus and 16 GB, read about 7% more slowly.

All 39 cards are compared side by side on the GPU index, and the same numbers from the model's point of view are on each model fit table. To check one specific pairing rather than read a table, use the can-I-run-it checker.

Questions

Can an RTX 4080 SUPER run a 70B model?
Not at Q4_K_M in one card. Llama 3.3 70B needs about 45.8 GB at 8k context and this card can address 16 GB. Your options are a smaller model, a harsher quantisation with very little context, splitting across two cards, or renting a larger one for the hours you need it.
What is the best model to run on an RTX 4080 SUPER?
Gemma 4 12B. At Q4_K_M and 8k context it needs about 8.2 GB of the 16 GB available and generates an estimated 74 tokens per second, which is faster than you can read. It also fits at Q8, at about 14.2 GB, which is worth taking when it fits.
How many tokens per second does an RTX 4080 SUPER generate?
It depends entirely on the size of the model, because generating a token means reading every active weight out of memory. At 736 GB/s and 70% efficiency, this card produces an estimated 111 tokens per second on an 8B model at Q4, and about 247 on the largest model it holds, gpt-oss 20B. Reading speed is roughly 5 to 8 words per second, so anything above 25 feels immediate. Treat 111 as a ceiling on 736 GB/s rather than a measurement; the higher a figure, the further real runtimes fall below it.
Is 16 GB enough for running LLMs locally?
It runs 12 of the 34 models tracked here at Q4_K_M with 8k of context, up to 21B parameters. The honest test is not the model list but the context: Gemma 4 12B on this card holds about 131,072 tokens before memory runs out.
RTX 4080 SUPER or RTX 3090 for local models?
The RTX 3090 holds more: 24 GB against 16 GB, so it runs 28 of these models to this card's 12. On speed, the RTX 3090 is faster: 936 GB/s against 736 GB/s, and bandwidth is what sets chat speed.
RTX 4080 SUPER or RTX 3090 for AI?
For language models, the 3090: it holds 24 GB against 16 GB and reads it at 936 GB/s against 736 GB/s, about 27% faster. The 4080 SUPER has newer Ada compute and FP8 support, which help image generation and prompt processing, and it draws 320 W against 350 W. For what fits and how fast it generates, the older card wins.
RTX 4080 SUPER or RTX 5070 Ti for AI?
Both have 16 GB on a 256-bit bus, so the same models fit. The 5070 Ti reads memory at 896 GB/s against 736 GB/s, about a fifth faster, runs FP4 formats natively and draws 300 W against 320 W. For language models, the 5070 Ti.
  • Memory: weights (parameters × bytes per parameter) + KV cache (2 × layers × KV heads × head dim × context × bytes for a standard transformer; sliding-window, hybrid and latent-attention models counted as they actually cache) + 0.5 GB runtime + 4% of weights. Full derivation in the VRAM calculator.
  • Speed: 70% × bandwidth ÷ active weight bytes, single stream, no batching, prompt processing excluded. A ceiling, not a measurement: the 6 of 12 figures marked ≤ are where real runtimes fall furthest below the number, because so few weights are read per token. See the tokens-per-second estimator.
  • Card specification (manufacturer figures): 16 GB, 736 GB/s, 320 W; see NVIDIA's own page for this card. The bandwidth figure: NVIDIA prints no figure for this card, so it is 256-bit × 23 Gbps ÷ 8, with the bus width from NVIDIA's page and the data rate from NVIDIA's RTX 40 SUPER launch article.
  • Model architecture values come from each model's published config; the self-hosted LLM guide explains what each one changes.