Methodology

How VRAMwise calculates its numbers

A VRAM requirement estimate is the sum of quantized model weights, the KV cache at your chosen context length, and runtime overhead — compared against the memory your hardware actually exposes. Every input and every formula used on this site is documented below.

Data sources

GPU specifications: VRAM capacity and memory bandwidth are taken from vendor specification sheets (NVIDIA, AMD, Intel, Apple). Each spec table cites its source and retrieval date.
Model architecture: Parameter counts, layer counts, hidden sizes, attention head configuration (including GQA), and default context windows come from the official configuration files published with each model.
Quantized file sizes: GGUF and similar quantized sizes are read from the published files in their repositories rather than re-derived, so rounding matches what you actually download.
Throughput references: Where measured tokens/sec figures appear, they are attributed to their source (community benchmark threads, vendor posts) with a link and the runtime version noted. Estimated figures are always labeled as estimates.

The estimation formula

Total memory needed to run a model:

total_vram = weights + kv_cache + overhead

weights   = quantized model file size (GB)
kv_cache  = 2 × layers × kv_heads × head_dim × context_tokens × bytes_per_element
overhead  = runtime buffers and scratch space, typically 0.5–2 GB

Variable definitions:

layers: Number of transformer layers in the model (from its configuration file).
kv_heads: Number of key/value attention heads. With grouped-query attention (GQA) this is smaller than the total head count, which shrinks the KV cache considerably.
head_dim: Dimension per attention head (hidden size ÷ total attention heads).
context_tokens: The context length you intend to run, in tokens — not the model's maximum.
bytes_per_element: 2 for FP16 KV cache; 1 for 8-bit KV cache where the runtime supports it.

The leading factor 2 accounts for storing both keys and values.

Worked example

Llama-class 8B model, Q4_K_M quantization, 8,192-token context, FP16 KV cache:

weights   = 4.9 GB            (published Q4_K_M file size)
kv_cache  = 2 × 32 layers × 8 kv_heads × 128 head_dim
            × 8192 tokens × 2 bytes
          = 1.07 GB
overhead  ≈ 1.0 GB            (typical llama.cpp allocation)

total     ≈ 4.9 + 1.07 + 1.0 = 6.97 GB

Verdict logic: an 8 GB card reports TIGHT here (under 15% headroom once the desktop's own VRAM use is counted), while a 12 GB card reports FITS. The same model at a 32k context needs about 4.3 GB of KV cache and no longer fits on 8 GB.

Hardware-side assumptions

Discrete GPUs: we subtract a small reserve for the display and OS compositor when the GPU also drives a monitor.
Apple Silicon: unified memory is not fully available to the GPU; we apply the platform's default GPU working-set limit (roughly 65–75% of total memory depending on capacity) rather than the headline RAM figure.
Speed estimates: generation is typically memory-bandwidth-bound, so estimated tokens/sec = usable bandwidth ÷ bytes read per token, with an efficiency factor stated on the tool page.

Update policy

Updates are additive: new models and GPUs are appended as they release, and existing entries are corrected when vendors revise specifications or an error is reported. Each page shows its last-updated date, which also feeds the sitemap. To report an error, use the contact page — corrections take priority over new content.

Estimates are informational; see the terms of use for the full disclaimer.

Frequently asked questions

How much VRAM does a local LLM actually need?

More than the model file size. Total VRAM is roughly the quantized weights plus the KV cache at your context length plus 1 to 2 GB of runtime overhead. A 7B model at Q4 is about 4.1 GB of weights, but at a 16k context it typically needs 7 GB or more in total.

Why does context length increase VRAM usage?

Because the KV cache stores attention keys and values for every token in the context, its size grows linearly with context length. Doubling the context roughly doubles the KV cache, which is why a model that fits at 4k context can fail to load at 32k.

Where does VRAMwise get its GPU and model data?

GPU memory and bandwidth figures come from vendor specification sheets (NVIDIA, AMD, Apple), model architecture numbers come from official model configuration files, and quantized file sizes come from the published repositories. Each data page links its sources next to the table.