LLM Hardware Calculator: Will This Model Run on Your Machine?

By Cedrick Reese, Ready Utilities

Last updated: September 2026

This LLM hardware calculator checks a model's size against your available memory to see whether it fits, and how much headroom you'd have. Every number below is computed live from the formula explained under "How this is calculated," not looked up from a table.

Common scenarios

Tap a scenario to load it into the calculator below.

Custom calculator

Which model?

Picking a listed model gives an exact context-memory figure. "Other" gives a range, since architecture varies.

Quantization

Typical context length you'll use

Where it will run

Available memory (GB)

Your GPU's VRAM, your Mac's total unified memory, or your system RAM.

Result ✓ Fits comfortably ≈5.5 GB needed of 12.0 GB

How this is calculated

Model weight memory follows the standard estimate used across the local-AI community: parameter count multiplied by bytes-per-weight for the chosen quantization format, with a 20% runtime overhead added for the inference engine itself (CUDA kernels, buffers, and similar). Bytes-per-weight: FP16 = 2.0, Q8 = 1.0, Q5_K_M ≈ 0.68, Q4_K_M ≈ 0.57. These are averages for real-world k-quant GGUF files, which mix bit depths internally rather than using a uniform bit width.

Context and KV cache memory is where most calculators guess. This one doesn't, for the models listed in the dropdown: KV cache size depends on a model's actual layer count and number of key-value attention heads, pulled from each model's real published architecture, not estimated from parameter count. Two models the same size can need very different amounts. Qwen 32B and Mistral Small 24B both use 8 key-value heads, but Qwen has 64 layers to Mistral's 40, so Qwen's context memory cost per token is about 60% higher despite being a similar overall size. Parameter count alone can't tell you that; the actual architecture can.

For a model not in the dropdown, exact architecture data isn't available, so the calculator shows a range instead of a single number: real models we checked range from about 0.0065 to 0.0179 megabytes of context memory per token per billion parameters, a nearly 3x spread. The fit/won't-fit verdict uses the higher end of that range, so it errs toward warning you early rather than telling you something fits when it might not.

The "fits comfortably" threshold reserves headroom for the operating system and other running programs: 10% on a dedicated GPU, 20% on Apple Silicon unified memory (shared with the OS), and 25% on CPU-only system RAM.

This page checks one quantization level against your hardware at a time. To see every level's size side by side before picking one, use the quantization calculator instead.

The weight-memory formula is checked against multiple independent, published sources on LLM quantization and inference memory (logged with URLs in this site's fact-check record). Context-memory figures for the models in the dropdown come from each model's real published architecture (layer count and key-value head count, pulled from their HuggingFace configuration files), not estimated from parameter count; DeepSeek's R1-Distill models use their confirmed base architecture per DeepSeek's own model card. The custom-size range is a stated approximation built from that same real-model data, not a separate guess. This page gets rechecked as new models are added to the dropdown.

Sources

Frequently asked questions

How accurate is this calculator?

Model weight memory is well-grounded. Context memory is exact for any model in the dropdown, since it's calculated from that model's real published architecture rather than estimated. For the Other / custom size option, architecture isn't known, so the calculator shows a range instead of a single number, and the fit verdict uses the higher end of that range so it errs toward an early warning rather than a false positive.

Why does the same model need less memory at Q4 than at FP16?

Quantization reduces the precision used to store each weight. FP16 uses 2 bytes per parameter. Q4 formats like Q4_K_M use roughly 0.57 bytes per parameter on average (real-world k-quant formats mix bit depths, so it's not an exact 4 bits everywhere). Lower precision means less memory, with some loss in output quality.

What if the model doesn't fit in my VRAM?

You can still run it by offloading part of the model to system RAM, or running entirely on CPU, though both are much slower than running fully in VRAM. A smaller model or a more aggressive quantization level is usually the better fix if speed matters.

Should I trust the exact number, or just the fit/won't-fit verdict?

Lean on the verdict more than the exact figure. The weight memory number is well-grounded, but the context overhead is an estimate, so a model marked as a tight fit could end up either fitting or not depending on your specific setup.