en

LLM VRAM Calculator

Check whether a local language model fits your VRAM and RAM: weights, KV cache, buffer and offload shown separately, in GB and GiB - locally, no upload.

This calculator gives a non-binding, model-based estimate and is not financial, tax or legal advice. More in the disclaimer
  • Bangladesh
  • Brazil
  • Bulgaria
  • China
  • Egypt
  • Euro area
  • France
  • Germany
  • India
  • Indonesia
  • Italy
  • Japan
  • Kenya
  • Malaysia
  • Mexico
  • Netherlands
  • Nigeria
  • Pakistan
  • Poland
  • Portugal
  • Russia
  • South Korea
  • Spain
  • Sweden
  • Taiwan
  • Thailand
  • Türkiye
  • Ukraine
  • United Kingdom
  • United States
  • Vietnam
Memory type
  • Graphics card with its own VRAM
  • Shared memory (unified memory)
  • CPU only, no GPU
Number of GPUs
VRAM per GPU (GiB)
Split across several GPUs
  • None: the model must fit on one GPU
  • Runtime splits the layers across the GPUs
Reserve per GPU for display and driver (GiB)
System RAM (GiB)
RAM reserve for system and apps (GiB)
Operating system (free text)
Runtime and version (free text)
Model and revision (free text)
Total parameters (billions, all experts for MoE)
Active parameters per token (billions, MoE only)
Bits per weight (quantization, effective)
Layers with KV cache
KV heads (fewer than query heads with GQA)
Dimension per head
Context used (tokens)
KV cache precision
  • 16 bit (FP16/BF16)
  • 8 bit
  • 4 bit
Parallel requests
Runtime buffer (GiB, assumption)
Uncertainty (±)
The unchanged example values match my model and my computer

Result

Example calculation only: change or confirm the values
Does the model fit?
5.65 GB · 5.26 GiB
Total memory needed
5.08 GB - 6.21 GB (± 10 %)
Uncertainty interval
3.50 GB · 3.26 GiB
Weights
1.07 GB · 1.00 GiB
KV cache
1.07 GB · 1.00 GiB
Runtime buffer (assumption)
8.05 GB · 7.50 GiB
Usable GPU memory
One GPU
GPU split
12.88 GB · 12.00 GiB
Free system RAM
0.00 GB
Offload to system RAM
Example calculation only: change or confirm the values
Largest context that fully fits (tokens)
Example calculation only: change or confirm the values
Highest bit width that fully fits
Not given (dense model)
Active parameters per token (MoE)
7 × 10⁹ × 4 bit ÷ 8
Weights formula
2 × 32 × 8 × 128 × 8,192 × 1 × 16 bit ÷ 8
KV cache formula
Editable example, not a specific model
Source of model values
Editable example, not your computer
Source of the memory values
Not specified
Model profile
Not specified
Operating system
Not specified
Runtime
Not available
Comparison with a public model profile

Memory usage (upper bound, %)

No verdictFitsTightExceeded

Same model at other quantizations

Same model at other quantizations
Bits per weightWeightsTotal (upper bound)Memory left
16 bit14.00 GB17.76 GB-9.71 GB
8 bit7.00 GB10.06 GB-2.01 GB
6 bit5.25 GB8.14 GB-0.08 GB
5 bit4.38 GB7.17 GB0.88 GB
4 bit3.50 GB6.21 GB1.84 GB
3 bit2.63 GB5.25 GB2.80 GB
2 bit1.75 GB4.29 GB3.77 GB
Is my file uploaded?

No. Everything runs in your browser - your file never leaves your device. How this is verifiable

No upload100% local
Your content stays with youno third-party access
Hosted in GermanyGlobal Content Delivery
Independently auditedTLS A+ · HTTP headers A+

Whether a language model runs locally is decided by memory first. The calculator splits the requirement into separate parts: the weights (parameter count times bits per weight divided by 8), the KV cache for the context you use, a runtime buffer and a visible uncertainty. Seven billion parameters at 4 bits give 3.5 GB of pure weights before any overhead is added. Every size is shown twice: in GB (10⁹ bytes) and in GiB (2³⁰ bytes), because graphics cards and RAM are counted in binary while model files are often listed in decimal.

The KV cache grows linearly with the context and follows the architecture: two (keys and values) times layers times KV heads times head dimension times tokens times bytes per element. Models with grouped-query attention have fewer KV heads than query heads and need correspondingly less cache. For mixture-of-experts models the total parameter count matters for memory, because all experts must be loaded; the active parameters per token only drive the compute. The table shows the same model at other quantization levels, plus the largest context and the highest bit width that fit completely.

Several graphics cards only add up when your runtime actually splits the layers across them; without a supported split, two cards with 8 GiB each are not one 16 GiB card. What does not fit into GPU memory can be offloaded to system RAM; the result names that part but says nothing about speed. No model profiles are built in: the prefilled values are an editable example, not a specific model. Enter the figures from the model card; everything is calculated in the browser and stored nowhere.

Free, no account - calculate as often as you like; your inputs stay on your device.

Specifications

Specifications
Input formatsForm inputs (no file)
ProcessingLocally in your browser (JavaScript)
File uploadNone

In 3 steps

  1. Enter the memory type, VRAM per GPU, number and split of GPUs, plus system RAM and reserves.
  2. Enter the model values from the model card: parameters, bits per weight, layers, KV heads, head dimension and context.
  3. Read the result, the split into weights, KV cache and buffer, the offload and the quantization alternatives.

Limitations: A memory fit is no promise about speed, runtime support or drivers. The runtime buffer and reserves are assumptions; runtimes need more or less depending on version, batch size and backend. The KV formula covers standard attention with GQA/MQA; sliding-window, MLA or hybrid architectures can need much less cache. No model or hardware data is built in.

FAQ

How much memory do a model's weights need?

Parameters times bits per weight divided by 8. Seven billion parameters at 4 bits are 3.5 GB or about 3.26 GiB, before KV cache and buffer are added. Quantization formats with scales sit slightly above their nominal bit width; enter the effective bits then (file size in bytes times 8 divided by the parameter count).

Why does the calculator show GB and GiB?

One GB is 10⁹ bytes, one GiB is 2³⁰ bytes, about 7 percent more. Graphics cards and RAM are counted in binary even when the box says GB; model files are often listed in decimal. Both values are shown separately so nothing gets mixed up unnoticed.

Do two graphics cards with 8 GB each count as one with 16 GB?

Only if your runtime splits the layers across both cards. Without a supported split the model has to fit on one card, and the calculator counts only that card's memory. Even with a split, each card needs its own reserve.

How does the calculator handle mixture-of-experts models?

For memory it uses the total parameters, because all experts must be loaded. The active parameters per token are only displayed; they affect the compute, not the space needed.

Does "fits" mean the model runs fast?

No. The calculator only checks memory. How fast a model answers depends on memory bandwidth, compute, runtime and offload. A part held in system RAM usually makes output much slower.

LLM VRAM Calculator: free and without an account?

Yes. Using it is free and needs no account: you can calculate as often as you like, and your inputs stay on your device.

Related tools

AI Token Calculator · Data Size Converter · Energy Cost Calculator · Compare AI models · PC Upgrade and PSU Planner · RAM and SSD Price per GB