This article was originally published on Best GPU for LLM. The full version with interactive tools, FAQ, and live pricing is on the original site.
Yes -- you can run a 70B model on a single GPU, but only with aggressive quantization. At Q2_K, Llama 3 70B compresses to roughly 25GB, which fits on the RTX 5090's 32GB with room for a short context window. The trade-off is measurable quality loss compared to Q4_K_M. Whether that trade-off is acceptable depends entirely on your use case.
See the recommended pick on the original guide
Who this is for
You want to run 70B-parameter models like Llama 3 70B, Qwen 2.5 72B, or DeepSeek-R1 70B on a single consumer GPU. You are willing to accept quantization trade-offs to avoid multi-GPU setups or cloud costs.
The VRAM math for 70B models
| Quantization | Model Size | KV Cache (4K ctx) | Total VRAM | Fits on RTX 5090 (32GB)? |
|---|---|---|---|---|
| Q2_K | ~25GB | ~1.5GB | ~27GB | Yes |
| Q3_K_S | ~29GB | ~1.5GB | ~31GB | Barely (short context) |
| Q3_K_M | ~32GB | ~1.5GB | ~34GB | No |
| Q4_K_M | ~40GB | ~1.5GB | ~42GB | No |
| Q8_0 | ~70GB | ~1.5GB | ~72GB | No |
| FP16 | ~140GB | ~1.5GB | ~142GB | No |
The only consumer GPU that fits a 70B model at any quantization is the RTX 5090 with 32GB. At Q2_K, you get a tight but workable fit. At Q3_K_S, you are at the absolute limit with minimal context window.
VRAM chart available at the original article
Play with the quant setting below and watch which cards drop out:
Quality impact of aggressive quantization
This is the part most guides skip. Dropping from Q4_K_M to Q2_K is not free:
- Perplexity increases 5-15% depending on the model. You will notice more factual errors and less coherent long-form output.
- Reasoning quality drops -- multi-step logic tasks suffer the most. Simple Q&A and summarization hold up better.
- Code generation degrades -- syntax accuracy drops noticeably at Q2. Use a 32B model at Q4 instead if code is your primary use case.
- Creative writing is less affected -- style and fluency remain mostly intact at Q2_K.
For tasks where 70B quality matters (complex reasoning, nuanced analysis), the quality loss at Q2_K may defeat the purpose of running a 70B model in the first place. A 32B model at Q4_K_M often produces better results than a 70B at Q2_K.
GPU options for single-card 70B
| GPU | VRAM | Best 70B Quantization | Speed | Verdict |
|---|---|---|---|---|
| RTX 5090 | 32GB | Q2_K (~25GB) | ~12 tok/s | Only single-GPU option |
| RTX 4090 | 24GB | Won't fit | -- | Too little VRAM |
| RTX 3090 | 24GB | Won't fit | -- | Too little VRAM |
The RTX 5090 is the only consumer card that can run 70B models without offloading. Every other card requires either multi-GPU or CPU offloading (which tanks speed to 2-5 tok/s).
See the recommended pick on the original guide
Partial offloading: the middle ground
If you own an RTX 4090 (24GB) and want to try 70B models, partial CPU offloading is possible through llama.cpp:
- Load 60-70% of layers on GPU, remaining on CPU RAM
- Expect 5-8 tok/s with a fast CPU and DDR5 RAM
- Requires 32GB+ system RAM alongside GPU VRAM
- Usable for batch processing, painfully slow for interactive chat
This is a compromise, not a solution. If you need 70B regularly, either get an RTX 5090 or use dual GPUs.
The dual-GPU alternative
Two RTX 4090s (48GB combined) run 70B at Q4_K_M with room for 8K context. This costs $3,200 but gives you significantly better quality than a single RTX 5090 at Q2_K. If 70B model quality is your priority, dual cards are the better path.
Which approach should you take?
If you want 70B on a single card and accept Q2_K quality, the RTX 5090 ($2,000) is your only option. If you want 70B at Q4_K_M quality, you need dual RTX 4090s ($3,200) or cloud GPUs. If you want the best single-GPU experience without quality compromise, run a 32B model at Q4_K_M on an RTX 4090 ($1,600) instead -- it often beats a degraded 70B in practical tasks.
Common mistakes to avoid
- Assuming Q2_K quality is "good enough" without testing. Run your specific tasks at Q2_K and Q4_K_M side-by-side before committing. The quality gap is task-dependent.
- Using CPU offloading for interactive chat. At 5-8 tok/s, you will wait 10+ seconds for short responses. Offloading is only viable for batch workloads.
- Buying an RTX 5090 specifically for 70B when 32B covers your needs. The 32B class of models (DeepSeek-R1 32B, Qwen 2.5 32B) handles most tasks well at Q4_K_M on an RTX 4090 for $400 less.
- Forgetting context length limits. At Q2_K on a 32GB card, you have roughly 5GB for KV cache. That limits you to 2K-4K context, which may not be enough for complex multi-turn conversations.
Our recommendation
Running 70B on a single GPU is technically possible but comes with real trade-offs. For most users, a 32B model at Q4_K_M on an RTX 4090 delivers better practical results than a 70B at Q2_K on an RTX 5090. If you specifically need 70B quality and want to stay on one card, the RTX 5090 is the only path -- just go in with realistic expectations about quantization impact.
See the recommended pick on the original guide
See the recommended pick on the original guide
A 32B model at good quantization almost always beats a 70B model at bad quantization. Size is not everything.
For dedicated 70B hardware planning, see our best GPU for Llama 70B guide. For the full RTX 5090 vs 4090 breakdown, check our 5090 vs 4090 comparison.
Frequently asked questions
Is a 32GB GPU enough to run a 70B LLM without quantization?
No. Without quantization, a 70B model in FP16 needs roughly 140GB of VRAM, and even near-lossless Q8 still needs around 70GB. A 32GB card like the RTX 5090 only fits a 70B model at aggressive Q2_K or Q3_K_S quantization, which comes with measurable quality loss. Running 70B unquantized requires datacenter-class hardware, not a consumer GPU.
How do I run a 70B LLM locally?
You have three realistic paths: a single RTX 5090 running Q2_K quantization with a short context window, dual GPUs such as two RTX 4090s (48GB combined) for Q4_K_M quality, or partial CPU offloading on a 24GB card, which drops speed to roughly 5-8 tok/s and only suits batch work. Tools like llama.cpp handle the layer splitting and offloading.
How much VRAM does a 70B model need at Q4 quantization?
At Q4_K_M, the model weights alone are roughly 40GB, and with KV cache overhead you need about 42GB of total VRAM — more than any single consumer card offers. That is why Q4-quality 70B setups use dual GPUs (two RTX 4090s give 48GB combined) or cloud instances. On a single 32GB card you are limited to Q2_K or Q3_K_S.
Is Q2_K quality good enough for a 70B model?
It depends on the task. Perplexity rises roughly 5-15% versus Q4_K_M, and multi-step reasoning and code generation suffer the most, while creative writing and simple Q&A hold up better. For complex reasoning work, a 32B model at Q4_K_M often produces better results than a 70B at Q2_K, so test your own workload side-by-side before committing.
Related guides on Best GPU for LLM
- Best Multi-GPU Setup for Local LLM in 2026 (Dual)
- Best Quantization for Local LLM in 2026 (Q4 to Q8)
- How Much VRAM for a 70B LLM in 2026? (Q4-Q8 Table)
Continue on Best GPU for LLM for the complete guide with interactive calculators and current GPU prices.
Top comments (0)