Hardware benchmarks
Tokens-per-second, memory bandwidth, and quantization quality loss, tagged verified, community-reported, or estimated. Right now every entry is estimated: the figures come from third-party measurements, published papers or bandwidth calculations, and each entry says which. None has been measured on LocalNodeOps hardware yet.
VRAM calculator
Estimate total VRAM for a given model size, quantization, and context length. Estimates only — see the note at the bottom.
Total required VRAM
- Model weights
- —
- KV cache
- —
- Runtime overhead (10%)
- —
- Total VRAM
- —
Live changes
- No changes yet — adjust a control above.
Generic estimate: weight size
is bits-per-weight × parameter count; KV cache uses the reference
architecture nearest to the size you enter (7B/13B/32B/70B: real
published models; 120B: extrapolated, no real model exists at that
exact size). Sizes between those references are labeled Rough
estimate and assume a dense model, so use a model-specific page for
an exact figure. Model-specific (HF-synced):
weight size is the exact .gguf file size fetched from
Hugging Face — no estimation. KV cache is still estimated.
For models whose published attention config is recorded on this site
(layers, KV heads, head dimension, and any sliding-window layout), it
is computed from that config. For every other model the calculator
falls back to the nearest reference bucket, but only when the model is
within 5B parameters of a bucket and is not a mixture-of-experts
model; otherwise no total is shown. Batch size is fixed at 1 in both
modes. Multiple GPUs: pooled
VRAM is the number of cards times the VRAM per card, compared against
the same total (weights + KV cache + 10% overhead). Engines:
llama.cpp reserves the KV cache for the full context when the model
loads. vLLM reserves 90% of VRAM by default (so the GPU needs the
total divided by 0.90) and allocates KV in 16-token blocks; its
overhead reuses the same 10% estimate, and it usually serves
safetensors rather than GGUF. Fit status:
offload assumes about 4 GB of system RAM stays with the operating
system. Your GPU: choosing a
card uses its VRAM. For Apple Silicon the GPU can use about 75% of
unified memory by default, with no separate system RAM to offload
into. Treat all figures here as a starting estimate, not a guarantee. Full formula and known
limitations: /methodology.
Looking for one specific model? See the VRAM requirements for each synced model.
Calculator FAQ
How accurate is the VRAM calculator?
It depends on the mode. In "Generic estimate" mode, both the model weight size and the KV cache figure are estimates based on a reference architecture for the selected size bucket. In "model-specific" mode, the weight size is exact (the real .gguf file size synced from Hugging Face). The KV cache is computed from the model’s published attention settings when LocalNodeOps has them on record, and otherwise estimated from the nearest reference architecture. Either way the total assumes an fp16 cache, a batch size of 1 and a 10% runtime overhead, so treat it as an estimate.
Where does the KV cache figure come from for synced models?
KV cache size depends on a model’s layer count, KV head count, and head dimension. The Hugging Face data this calculator syncs gives exact .gguf file sizes but no architecture details. For some models LocalNodeOps records the published attention settings and computes the KV cache from them. For the others, the calculator matches the nearest reference architecture (7B, 13B, 32B, 70B or 120B) by parsing an approximate parameter count from the model name, only when the match is within 5B and the model is not a mixture-of-experts. Otherwise no total is shown. See /methodology for the exact formula and its limitations.
Does more VRAM always mean I can run a bigger model?
No. VRAM is consumed by three separate things: model weights, KV cache, and runtime overhead. A long context window can consume more VRAM than the model weights themselves, especially on older MHA-style architectures. Sizing for weights alone is the most common mistake people make.
What does "Fits on" actually check?
It compares the estimated total VRAM (for vLLM, the total divided by 0.90) against the VRAM of the cards in the list, multiplied by the number of GPUs you choose. The list covers common consumer cards plus two workstation and datacenter cards (RTX 6000 Ada and A100) that are shown for reference only. It does not account for VRAM already in use by your OS, other applications, or a second model already loaded.
RTX 4090 24GB
24GB of GDDR6X at about 1,008 GB/s. Fits 32B-class Q4 models at 8K context; a 70B at Q4 needs about 40GB and still requires CPU offload.
View benchmarkRTX 4060 Ti 16GB
16GB at about 288 GB/s. Roomy for 8B models at Q8_0 and long context, but memory bandwidth, not VRAM, caps speed.
View benchmarkRyzen 9 7950X
A CPU-only fallback for 7B models. Memory bandwidth, not core count, sets the speed.
View benchmarkDDR5-6000 Dual Channel
Theoretical peak for dual-channel DDR5-6000. Real sustained bandwidth is lower, and it sets the speed of any model layers that run from system RAM.
View benchmarkGGUF Q4_K_M
A common default for consumer GPUs: about 3.3x smaller than FP16 on Llama 3 8B, for a small perplexity increase.
View benchmarkAWQ 4-bit
GPU-focused 4-bit weight quantization. The perplexity cost varies by model, from about +0.07 to +0.40 in published tables.
View benchmarkMac Mini M4 16GB
16GB unified memory shared between CPU, GPU, and OS. By default macOS lets the GPU use about 75% of it (around 12GB), not the full 16GB.
View benchmarkRTX 5090 32GB
32GB GDDR7 at 1,792 GB/s bandwidth. Fits 32B-class Q4 models fully on the GPU; a 70B at Q4 still needs CPU offload.
View benchmark