1. Learn
  2. Know what matters

Why memory bandwidth sets LLM speed (and how to estimate tokens per second)

The one spec that predicts how fast a GPU runs a local model, the formula we use, and why a 2016 data-center card can beat a new gaming card.

Updated Oct 26, 2026 · RunItLocal.io

When people compare GPUs for gaming they look at compute. For running a language model, the number that matters most is memory bandwidth: how many gigabytes per second the card can read from its own memory.

Why bandwidth, not compute

To produce each token, the model reads all of its active weights from memory once. The math on those weights is quick; waiting for the data to arrive is the slow part. So:

tokens per second ≈ memory bandwidth ÷ size of the active weights × efficiency

Efficiency covers everything that isn't perfect: overhead, cache misses, the software. On our rack, dense models reach about 55% of the ceiling, and mixture-of-experts models about 35%.

Try it

An RTX 3090 has 936 GB/s. Qwen3 32B at 4-bit is about 20 GB:

936 ÷ 20 × 0.55 ≈ 26 tok/s

That's comfortably faster than you can read. Our calculator does exactly this for every card and model we track, and it's usually within about a third of real results.

Why an old card can beat a new one

CardYearBandwidthQwen3 14B, estimated
RTX 4060 Ti 16 GB2023288 GB/s~17 tok/s
Tesla P100 16 GB2016732 GB/s~43 tok/s
RTX 3090 24 GB2020936 GB/s~55 tok/s

The P100 is a 2016 data-center card with no tensor cores, and it's more than twice as fast as a new mid-range gaming card on this job, because it has fast HBM2 memory. We run a rack of them; see the P100 for local LLMs.

Where the formula breaks down

  • Prompt processing is different. Reading a long document into the model is compute-bound, not bandwidth-bound. Newer cards with tensor cores are far faster at it. If you paste in huge documents, compute matters too.
  • Mixture-of-experts models only read the experts they use per token, so they run much faster than their size suggests. See mixture of experts explained.
  • Spilling onto the CPU drops you to system memory bandwidth, typically 50 to 100 GB/s. That's why a model that doesn't fit gets so slow.
  • Two GPUs splitting a model by layers run at about the speed of one card, with twice the memory. Splitting every layer across cards (tensor parallel) can be faster, but needs server software like vLLM.

Macs

Apple silicon has a lot of bandwidth for a laptop: an M4 Max reads at about 546 GB/s, and an M3 Ultra at about 819 GB/s. That's why big-memory Macs run large models well. See Macs for local LLMs.

See it for any card

Tesla P100, 16 GB · estimated with our calculator · full page

  • Qwen3 4BQuick everyday chat and summaries
    ~160 tok/s
    Runs greatqwen3:4b
  • Qwen3 8BA solid all-rounder for chat and writing
    ~77 tok/s
    Runs greatqwen3:8b
  • Gemma 3 12BReads images as well as text
    ~50 tok/s
    Runs greatgemma3:12b
  • Qwen3 14BNoticeably smarter at reasoning and code
    ~43 tok/s
    Runs greatqwen3:14b
  • gpt-oss 20BOpenAI's open model. Fast, strong reasoning
    ~130 tok/s
    Runs greatgpt-oss:20b
  • Gemma 3 27BGoogle's best open model for its size
    needs 19 GB
    Too biggemma3:27b
  • Qwen3 30B-A3B30B smarts at small-model speed
    needs 21 GB
    Too bigqwen3:30b
  • Qwen3 32BStrong coding and long answers
    needs 22 GB
    Too bigqwen3:32b
  • Llama 3.3 70BClose to the big cloud models
    needs 45 GB
    Too bigllama3.3:70b
  • gpt-oss 120BOpenAI's largest open model
    needs 67 GB
    Too biggpt-oss:120b
  • Qwen3 235B-A22BAlibaba's flagship open model, for multi-GPU rigs
    needs 144 GB
    Too bigqwen3:235b
  • DeepSeek R1 671BThe full DeepSeek R1, for the biggest rigs
    needs 406 GB
    Too bigdeepseek-r1:671b

Pick any card on every GPU to see the same estimate for it.