Interactive Utility
Mistral Small 3 (24B) VRAM Calculator
Stop guessing your hardware needs for Mistral Small 3 (24B). Calculate the exact VRAM required for inference based on parameter count, quantization, and KV cache, and see which machines can actually run it.
Model
Custom: billion
The community default. Best size-to-quality ratio.
Memory to run it
- Weights (Q4_K_M)
- 14.5 GB
- KV cache (8k)
- 2.6 GB
- Runtime overhead
- 1.5 GB
- System RAM to load
- 17 GB
- Model file on disk
- 15.3 GB
Hardware match
RTX 3090 / 4090 (24GB) or Mac Studio (64GB)
At the limit of a single consumer GPU.
Rough decode speed
~41 tok/s
Ballpark on RTX 4090-class, bounded by memory bandwidth. Real numbers land 30–50% either side depending on framework, prompt length and thermals.
Mistral Small 3 (24B) memory requirements by quantisation
Estimated at an 8k-token context. Mistral Small 3 (24B) is 24B parameters; the arithmetic and its assumptions are set out below.
| Quantisation | Weights | Total VRAM | Runs on |
|---|---|---|---|
| FP16 (unquantised) | 48.0 GB | 52.1 GB | Mac Studio Ultra (128GB) or an 80GB data-center GPU |
| Q8_0 (8-bit) | 25.5 GB | 29.6 GB | 2× RTX 3090 / 4090, or Mac Studio (64GB+) |
| Q6_K (6-bit) | 19.8 GB | 23.9 GB | RTX 3090 / 4090 (24GB) or Mac Studio (64GB) |
| Q5_K_M (5-bit) | 17.1 GB | 21.2 GB | RTX 3090 / 4090 (24GB) or Mac Studio (64GB) |
| Q4_K_M (4-bit) | 14.5 GB | 18.6 GB | RTX 3090 / 4090 (24GB) or Mac Studio (64GB) |
| Q3_K_M (3-bit) | 11.7 GB | 15.8 GB | RTX 4080 (16GB) or Mac mini (24GB) |
Arithmetic over stated assumptions, not a benchmark. Weights are parameter count times bits-per-weight; the KV cache term assumes grouped-query attention; 1.5GB is reserved for runtime overhead.
Size a related model
Embed this Mistral Small 3 (24B) Calculator
Add this exact configuration to your blog, documentation, or internal wiki.
<iframe src="https://fathomlayer.com/embed/hardware-calculator?p=24" width="100%" height="600" frameborder="0" style="border-radius: 12px; border: 1px solid rgba(255,255,255,0.1);"></iframe>
How this math works
Running Large Language Models locally is entirely bottlenecked by memory. Raw compute (TFLOPS) dictates your generation speed, but VRAM capacity dictates if the model will load at all.
- Model Weights: At FP16 (unquantized), every 1 Billion parameters requires ~2GB of VRAM. At Q4 (4-bit quantization), that drops to ~0.7GB per 1B parameters.
- KV Cache (Context Window): As you feed text into the model, it stores attention states in memory. A 32k context window on a 70B model requires several extra Gigabytes of RAM independent of the model weights.
- Overhead: CUDA and operating systems reserve memory (usually 1-2GB), meaning a 24GB RTX 4090 cannot realistically load a 23.5GB model.