DeepSeek-V3.2 VRAM requirements: can you run it locally?

DeepSeek-V3.2 is DeepSeek's large mixture-of-experts model with DeepSeek Sparse Attention (DSA), released as a fine-tune of V3.2-Exp. Hugging Face lists 685,355,329,792 parameters (most stored in FP8), the repo was created on 2025-12-01, and the license is MIT.^[1] config.json sets 163,840 positions.^[2] Hugging Face counts about 6,909,222 downloads in the last 30 days (checked November 3, 2026).^[1]

Memory needed at each quantization

Quantization stores each weight in fewer bits. Smaller files fit on smaller GPUs, at some cost in quality, and the cost grows below about 4 bits. Below is every GGUF build we could source, using the exact file sizes on Hugging Face (1 GB = 1,000,000,000 bytes; split files added together), largest first.^[3] DeepSeek publishes FP8 safetensors, not GGUF, so sizes are from Unsloth's unsloth/DeepSeek-V3.2-GGUF (split files added together).

Which quant should you pick? Q4_K_M is the usual balance of size and quality. Use Q5_K_M or Q6_K if you have the memory, and Q8_0 if you want results close to the original. Treat 2-bit and 3-bit builds as a last resort.

Context length adds memory (the KV cache)

On top of the weights, the engine keeps a key/value cache for every token. DeepSeek-V3.2 uses Multi-head Latent Attention: instead of full keys and values, engines such as llama.cpp cache one compressed latent per layer. From config.json (61 layers, kv_lora_rank 512, qk_rope_head_dim 64),^[2] an FP16 cache takes 61 × (512 + 64) × 2 bytes = 70,272 bytes per token. The small extra key cache used by the sparse-attention indexer (index_head_dim 128) is not included, and engines that expand the latent use more.

Some engines can store the cache in 8-bit to roughly halve it.

Which GPUs and Macs it fits on

Pick your GPU or Mac and a context length to see which quantizations fit. The weights plus the KV cache are compared with the device's memory.^[4][5][6][7]

How to read it: "Fits" means weights + cache use under 90% of memory. "Tight" means 90–100%: it may load, but the engine's own working memory or a longer context can push it over. "No" means it won't fit on the GPU alone. The 90% line is our own rule of thumb, not a vendor figure. On a Mac, macOS also needs some of the unified memory, so treat Mac rows as optimistic.

Our recommendations

No single consumer or workstation GPU in our list holds any build of DeepSeek-V3.2, so we don't give per-card picks. Use the picker above for multi-GPU setups and the Mac Studio.

How to run it

With a recent llama.cpp build that supports DeepSeek-V3.2, download a GGUF file from the quant list above (for example the Q4_K_M build) from unsloth/DeepSeek-V3.2-GGUF.^[3] If the model is bigger than your VRAM, these tools can keep some layers in system RAM, but every token then waits on the slower memory, so expect much lower speed.

Cheapest GPU to rent for DeepSeek-V3.2

On-demand prices listed on Runpod's pricing page for 8-GPU setups that hold Q4_K_M with an 8K context. Runpod lists per-GPU prices; these rows are that price times 8, and 8-GPU availability varies (checked November 2, 2026; Community Cloud is cheaper but runs on shared hosts):^[8]

See all GPU rental prices for Lambda, Vast.ai and multi-GPU setups, or compare it with other models in the VRAM table.^[9]

Frequently asked questions

How much VRAM does DeepSeek-V3.2 need at 4-bit?

About 406.0 GB for the Q4_K_M weights (405.4 GB) plus an 8K-token FP16 KV cache (0.58 GB), before engine overhead.^[3][2]

What is the smallest GPU that runs DeepSeek-V3.2?

No single GPU does. In our list, eight 80 GB H100s (640 GB total) hold Q4_K_M with an 8K context under our 90% rule, as does a 512 GB Mac Studio. With less memory, llama.cpp can keep the experts in system RAM, at much lower speed.^[3]

How much does the full 160K context add?

At FP16 the KV cache for 163,840 tokens is about 11.51 GB (32K tokens: 2.30 GB).^[2]

How we calculated

• Weights are the exact GGUF file sizes on Hugging Face, checked November 3, 2026.^[3]
• KV cache is calculated from config.json. We assume an FP16 cache.^[2]
• Device memory is from NVIDIA and Apple spec pages. We compare in decimal GB, so the results lean conservative.
• Rental prices are the listed on-demand Runpod rates, checked November 2, 2026.^[8]
• Not included: engine working buffers, the vision/audio projector, the OS and display. These vary by engine and settings, so leave headroom.

Sources

All sources checked on 2026-11-03.

1. Hugging Face, deepseek-ai/DeepSeek-V3.2 (parameter count, license, repo date, 30-day downloads; checked November 3, 2026). https://huggingface.co/deepseek-ai/DeepSeek-V3.2
2. Hugging Face, deepseek-ai/DeepSeek-V3.2 config.json (layers, KV heads, head size, context). https://huggingface.co/deepseek-ai/DeepSeek-V3.2/blob/main/config.json
3. Hugging Face, unsloth/DeepSeek-V3.2-GGUF file list (exact GGUF sizes; checked November 3, 2026). https://huggingface.co/unsloth/DeepSeek-V3.2-GGUF/tree/main
4. Apple, Mac Studio tech specs (up to 512 GB unified memory) https://www.apple.com/mac-studio/specs/
5. NVIDIA, H100 (80 GB) https://www.nvidia.com/en-us/data-center/h100/
6. NVIDIA, H200 (141 GB) https://www.nvidia.com/en-us/data-center/h200/
7. Runpod, GPU pricing (B200 180 GB, B300 288 GB memory as listed) https://www.runpod.io/pricing
8. Runpod, GPU pricing (checked November 2, 2026). https://www.runpod.io/pricing
9. VRAMNeeded comparison table (sources listed per model). https://vramneeded.com/compare/