LLMBOTTLENECK.COM

Local LLM VRAM & speed calculator

WILL IT RUN ON YOUR MACHINE?

Pick a model and a GPU or a Mac. Get a straight yes or no on whether it fits in memory, an estimated speed in tokens per second, and the one change that fixes it when it does not.

Memory fit is calculated from published specifications and files; speed is an estimate. Neither is a test on your machine. How to read the answer

Models catalogued
327
GPUs and Macs
135
Models with a format to size
320
Snapshot date
2026-10-03

llmb run qwen3-8b --device rtx-4090 --quant Q4_K_M --ctx 8192

weights · Q4_K_M5.03 GB
kv cache · 8,192 ctx1.21 GB
runtime reserve0.80 GB
device memory · RTX 409024.0 GB
memory used7.04 GB / 24.0 GB · 29.3%

It fits

Qwen3-8B · Q4_K_M · RTX 4090

Tokens / second, est.
~116
Memory needed
7.04 GB
Spare capacity
17.0 GB

Calculated, not measured on your machine.Run your own →

Start here

Two ways in

Begin with the machine you own or with the model you want. Either one ends on a page that answers it.

Start from your hardware

I have this machine — what can I run?

Pick your GPU or computer. You will choose its memory configuration next.

Reads the graphics name your browser shares. Nothing is sent anywhere.

Popular:
135 devicesBrowse all →
Start from a model

I want to run this model — what do I need?

Pick a model to see the memory each format needs and which devices hold it.

Popular:
320 models with a format to sizeBrowse all →
Calculator

Check one exact combination

Pick a model, a device, a format and a context length. Every input names its source.

$calcqwen-qwen3-8b--device nvidia-geforce-rtx-4090--quant Q4_K_M--ctx 8192--offload

320 models can be sized by the calculator. View all 327 architectures. A fine-tune or a GGUF file not listed? Paste its Hugging Face link.

Capacity and bandwidth from the manufacturer's specification.

Weight format

Q4_K_M · published file

8,192 tokens
Qwen’s configured maximum is 40,960 tokens.
Multiple GPUs · usable memory per device
Hardware configuration

Memory is divided between devices; every device keeps its own runtime reserve.

Costs · rental, electricity, carbon
Advanced · KV cache format, batch, concurrent users, runtime reserve
↑ View result

Saved configurations

Nothing saved yet. Saved on this browser only; use the link to share a configuration or keep a copy elsewhere.

Result updated. It fits in device memory, 29 percent of device memory.

Qwen3-8B · Q4_K_M · NVIDIA GeForce RTX 4090 · 8,192 ctx · offload
High confidencewhy?

The model file's size is published, byte for byte. The runtime's own reserve is an estimate, but it is small against the room left here. Speed is always an estimate, never a measurement on this machine.

89% of the bytes from published sources.

AnswerunvalidatedWeightspublished dataArchitecturepublished data

IT FITS

Fits in device memory: 7.04 GB needed of 24.0 GB of device memory.

Sized for: NVIDIA GeForce RTX 4090, 24 GB, 1008 GB/s

29.3%of device memory · comfortable
tokens per second
~116

Faster than you read

time to first token · floor 0.75s
~7.8s

for a 8,192-token prompt, one request, no queue

spare capacity
17.0 GB

7.04 GB needed of 24.0 GB

Where the memory goes

Weights · Q4_K_M
5.03 GB
KV cache · 8,192 ctx
1.21 GB
Runtime reserve
0.80 GB
Needed
7.04 GB of 24.0 GB published capacity

What to do

NOTHING TO FIXVerdictestimate

17.0 GB spare and ~116 tok/s — above the 30 tok/s this site treats as faster than reading.

Weakest link: the 0.80 GB runtime reserve, which is an uncalibrated prior rather than a measurement

RECOMMENDED

Change nothing. This configuration fits comfortably as it is; no upgrade is suggested without a speed target.

Ruled out: Spending on memory or bandwidth buys nothing here: neither is the constraint at this size and context.

What this answer covers

File
a published file with these bytes exists
Runtime
not tested for this model and machine — fitting in memory does not guarantee it loads.
Speed
estimate, not a measurement

Next step

Store and cloud links may pay us a commission. They never decide the answer above — the memory arithmetic does.

Snapshot ZOAGzSDaZvVT · catalogue 2026-10-03Open the pair page →
What the labels mean
published data
Read from a published source — a file's byte count, a model's configuration or a manufacturer's specification — or exact arithmetic on such values. Not a measurement on a machine.
estimate
Calculated from sourced inputs by a stated method; an estimate, not a measurement.
unvalidated
Rests on at least one assumption that has not been measured, such as the runtime reserve.
reconstructed size
Weight size reconstructed from the pinned architecture, because no published file exists.
size range
Only a lower and an upper bound are claimed for this weight size.
Under the hood

How this answer was built

Open what you need. The answer above does not depend on reading any of it.

Memory against context lengthHow the requirement grows as the conversation gets longer.
0 GB6 GB13 GB19 GB25 GBdevice ceiling1K2K4K8K16K32K40K
Every sampled context length, up to 40K tokens, stays inside the published capacity. Dashed green marks your context of 8,192 tokens.
Sampled values
ContextMemoryWithin 24.0 GB
1,024 tokens5.98 GByes
2,048 tokens6.13 GByes
4,096 tokens6.43 GByes
8,192 tokens7.04 GByes
16,384 tokens8.24 GByes
32,768 tokens10.7 GByes
40,960 tokens11.9 GByes
The basis of each memory figureWeights 5.03 GB, cache 1.21 GB, reserve 0.80 GB — and which of them is published data.
ComponentBytesBasis
Weights5.03 GBpublished data published file
KV cache1.21 GBpublished data exact tensor geometry
Runtime reserve0.80 GBunvalidated uncalibrated prior
GPU power ceilingAt most 450 W while generating — the card, not the whole computer.

At most 450 W while generating, so no more than 10.8 kWh a day running continuously.

Why this is an upper bound

  • Accelerator energy ceiling at 24 hours a day (default: continuous); this is not the whole machine's bill.
  • 450 W is the TGP the manufacturer publishes, which is the most the board may draw — not what decoding draws. Generation is bandwidth-bound and sits below this limit by an amount no vendor publishes, so every figure here is an upper bound.
  • Only the accelerators are counted. The rest of the machine — CPU, memory, drives, fans, and the power supply's own conversion losses — draws more on top, and none of it is specific to the model you chose.
  • No electricity price was given, so no bill is shown. Rates differ several-fold between countries and there is no default worth quoting.
  • No grid carbon intensity was given, so no emissions figure is shown. Intensity varies by more than tenfold between regions and by the hour within one, so a single global average would be a worse answer than none.
Evidence and limitationsHow the file size was obtained, and what was withheld.

Published GGUF file size at a pinned revision.

Open the pinned GGUF source ↗

  • No decode fit exists for CUDA with Q4_K_M; the Q4_0 fit on the same backend is used instead.
  • Fitted utilisation varies by 1.2% across the three formats calibrated on Metal, which is the measured size of this substitution.
  • Calibration sample count is 2 (<5); this calibrated estimate may not generalize.
  • Utilisation is solved from one published benchmark on one device and backend. It is applied to other hardware as a first-order extrapolation, not as a measurement of that hardware.
  • The compute roof uses the dense matrix-unit peak the vendor publishes, which is the unit the runtime dispatches prefill to. Sparsity-doubled figures are never used.
  • Tokenizer time, graph build and prompt-shape effects are outside this equation.
  • Published device capacity is a hardware ceiling; display, driver, and runtime allocations can reduce free memory.
Reading the result

How to read the answer

Three questions, in the order the answer gives them. The terms it uses are explained beside them.

  1. Does it fit?

    A model has to sit in the graphics card’s own memory to run properly. Three things go in there — the model file, the memory the conversation needs, and what the software reserves for itself — and the answer is whether all three fit in what the card has.

  2. How fast?

    Writing each word means reading the whole model out of memory again, so speed is usually decided by how fast the card’s memory is rather than by how powerful the chip is. That is why an older card with fast memory can beat a newer one with slow memory.

  3. What would fix it?

    One change, with the number attached — and what will not help, which matters just as much. A faster card does nothing if what you ran out of was memory.

Terms and questions

How much VRAM do I need to run a local LLM?

Enough for three things at once: the model file at the format you choose, the memory the conversation needs, and what the software reserves for itself. As a worked example from this catalogue: Qwen3-8B at Q4_K_M with 8,192 tokens of context needs 7.04 GB, against the 24.0 GB a RTX 4090 has.

What is quantization, and which one should I pick?

Storing the model with less precision so the file gets smaller. Q4_K_M is about a quarter the size of the original and is what most people download; Q8_0 is about half; FP16 is the full thing. Smaller fits on cheaper hardware and answers slightly worse. The usual choice is the largest format that still fits with room for the conversation.

What does context mean?

How much of the conversation the model can see at once, counted in tokens — roughly three quarters of a word each. Longer context needs more memory, and on some models a great deal more.

Why does a long conversation run out of memory?

Because of the KV cache. The memory holding that conversation. It grows as you type, and it is usually what runs out first on a long chat — which is why a model that loaded fine can fail an hour later. Each model-and-device page states the longest context that still fits.

Can I run a model that is bigger than my GPU’s memory?

Often, by offloading. Keeping part of the model in ordinary system memory when it will not all fit on the card. It runs, but slowly: system memory is typically ten to twenty times slower than a graphics card's own.

How accurate is the speed estimate?

It is an estimate, not a test on your machine. The measured error, worst cases included, is published on the accuracy page.

Evidence

Nothing is made up

  • 320 models

    Read from the publisher’s file

    Each model’s architecture is read from the file its own publisher released, at a fixed version we record. Where a figure was never published, this site says so instead of filling the gap.

  • Three tiers

    The file, or rebuilt from it

    When the exact file exists, its published size is used byte for byte. When it does not, the size is rebuilt from the architecture — and the answer tells you which of the two you are looking at, every time. Neither is a measurement taken on a running machine, and the site does not call them one.

  • Scorecards / per corpus

    Our error is published

    Including the cases this engine handles worst, on the same page as the ones it handles best.

    See the scorecard →
Building something?

The same answers, by API

A key is issued the moment you ask for one. 200 calls a day, and a page that shows exactly what you have used.

Get a free key →

Selling hardware?

Put this on your product page

One script tag answers “which models does this card run?” on your own site, and where a figure is not published the widget says so instead of estimating one.

See it working →

llmbottleneck
catalogue 2026-10-03models 327devices 135