Moonshot AI · VRAM requirements
Kimi K3.1 Pro VRAM requirements: 1.56 TB official, 593 GB smallest GGUF
We earn commissions when you shop through the links below.
- Parameters2.8T (104B active)
- Context1M
- Official weights1,561.3 GB
- Checked2026-11-10
Quick answer
Kimi K3.1 Pro's official MXFP4 weights are 1,561.3 GB (about 1.56 TB), almost exactly the size of Kimi K3, and there is no 16-bit release.[4][2] Full quality needs about eight B300s (vLLM's baseline is TP8 on one B300 node or two GB300 trays).[8] The smallest full community GGUF, KLX-IQ1_S, is 592.7 GB: tight on 8× H100 (640 GB).[6] A 75%-expert-pruned build is 475.5 GB, but its makers say to expect a large quality drop.[7] No single GPU or Mac holds it.
Kimi K3.1 Pro is Moonshot AI's follow-up to Kimi K3, post-trained from K3 with large-scale reinforcement learning. The Hugging Face repo was created on November 2, 2026 under the Kimi K3.1 Pro License and showed 27,926 downloads and 1,807 likes when we checked on November 10.[1] The model card lists 2.8 trillion total parameters with 104B active per token, a 1,048,576-token context window and native image input.[2]
What changed from K3 (memory-wise): the layout is the same (93 layers, 896 routed experts with 16 per token plus 2 shared, MXFP4 experts), but the 24 full-attention layers switch from Gated MLA to Gated DeepSeek Sparse Attention (DSA) with a top-2048 indexer.[2][3] The weights are about the same size; the per-token cache is slightly bigger because DSA also stores an indexer key (see below).
Memory needed at each build
Below are Moonshot's official checkpoint and the community builds on Hugging Face, using the exact file sizes (1 GB = 1,000,000,000 bytes, multi-file builds summed), largest first.[4][5][6][7] The vision projector (mmproj, 0.9 GB at BF16 in the DevQuasar repo) is only needed for image input and is not included.[5]
| Quantization | Weights | |
|---|---|---|
MXFP4 (official) Moonshot's release | 1,561.3 GB | |
MXFP4_MOE GGUF DevQuasar, experimental | 1,508.9 GB | |
Q2_K GGUF DevQuasar | 1,009.3 GB | |
KLX-IQ2_XXS | 709.9 GB | |
KLX-IQ1_M | 647.9 GB | |
KLX-IQ1_S smallest full build | 592.7 GB | |
Pruned 75% (vLLM project) 224 of 896 experts; big quality loss | 475.5 GB |
Why there is no "Q4_K_M" or "Q8_0" here: like K3, the official release is a 4-bit model (MXFP4 experts from quantization-aware training, everything else BF16), so an 8-bit file would not be smaller and a standard 4-bit GGUF saves only about 3%.[2][3] DevQuasar's MXFP4_MOE GGUF (1,508.9 GB) is that 3% saving; its card calls it "VERY EXPERIMENTAL" and it was made with a llama.cpp branch.[5] Real savings start below 4 bits.
Which small build? KarLexAI's KLX builds (IQ1_S 592.7 GB, IQ1_M 647.9 GB, IQ2_XXS 709.9 GB) say they run on stock llama.cpp. KarLexAI reports mean KL divergence 0.106 / 0.084 / 0.072 against the full model, and that IQ1_S runs fully on one 8× H100 node with 131K tokens of context at 19 tokens/s.[6] Those are the uploader's own numbers; we have not reproduced them, and the repo is small (603 downloads at our check).
The pruned build is a different trade-off. The vLLM project's Kimi-K3.1-Pro-pruned75 keeps 224 of 896 routed experts per layer (75% removed, no calibration data). Its card says it is for "serving and evaluation smoke tests on fewer GPUs, not for quality-sensitive use" and reports GSM8K 43.7%, run at TP=4 on B300.[7] Treat it as a test build, not as Kimi K3.1 Pro.
Context length adds memory (the KV cache)
Of the 93 layers, config.json lists 69 Kimi Delta Attention (linear) layers, which keep a fixed-size state, and 24 DSA layers that grow with the conversation.[3] Each DSA layer stores a 512-value compressed latent plus a 64-value position key per token (as in K3), and the DSA indexer adds a 128-value key per token (index_head_dim 128).[3] vLLM's recipe confirms both the latent and the indexer-key caches are kept.[8] At BF16 that is about 33,792 bytes per token, roughly 22% more than K3's 27,648. Moonshot has not published a per-token figure, so treat this as our estimate; engines may store the indexer key in FP8 and use less.
| Context | KV cache (our estimate, BF16) |
|---|---|
| 4,096 tokens | 0.14 GB |
| 8,192 tokens | 0.28 GB |
| 32,768 tokens | 1.11 GB |
| 1,048,576 tokens (max) | 35.43 GB |
So even the full 1M-token window adds about 35 GB, small next to 1.56 TB of weights. vLLM's recipe reports that on 8× B300 with FP8 KV, plain TP8 holds about 2.6M cached tokens and decode context parallelism (DCP8) about 18.5M.[8]
Which GPU setups and Macs it fits on
Each cell compares the weights plus an 8K-token KV cache with the total memory of the setup.[9][10][11][12]
Full table: every device × quantization at 8,192 tokens
| Device | MXFP4 (official)1,561.6 GB | MXFP4_MOE GGUF1,509.2 GB | Q2_K GGUF1,009.6 GB | KLX-IQ2_XXS710.2 GB | KLX-IQ1_S593.0 GB | Pruned 75% (vLLM project)475.8 GB |
|---|---|---|---|---|---|---|
| Mac Studio512 GB unified | No | No | No | No | No | Tight |
| 4× H200 (141 GB each)564 GB | No | No | No | No | No | Fits |
| 8× H100 (80 GB each)640 GB | No | No | No | No | Tight | Fits |
| 8× H200 (141 GB each)1128 GB | No | No | Fits | Fits | Fits | Fits |
| 4× B300 (288 GB each)1152 GB | No | No | Fits | Fits | Fits | Fits |
| 8× B200 (180 GB each)1440 GB | No | No | Fits | Fits | Fits | Fits |
| 8× B300 (288 GB each)2304 GB | Fits | Fits | Fits | Fits | Fits | Fits |
Column headers show weights + an 8,192-token KV cache (our estimate from config.json). Multi-GPU rows assume the model is split evenly across all GPUs. The pruned build removes 75% of the experts and loses a lot of quality (see below); it is not the same model.
How to read it: "Fits" means weights + 8K cache use under 90% of memory. "Tight" means 90–100%: it may load, but the engine's own buffers or a longer context can push it over. "No" means it won't fit. 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 that row as optimistic.
Our recommendations
These follow from the tables above.
| Your setup | Best build that fits comfortably | Notes |
|---|---|---|
| 512 GB Mac Studio | none fully in memory | Even the pruned build (475.5 GB) is tight (93%) |
| 4× H200 (564 GB) | Pruned 75% (475.5 GB) | Test build only; no full build fits |
| 8× H100 (640 GB) | Pruned 75% (475.5 GB) | KLX-IQ1_S (592.7 GB) is tight (93%); KarLexAI says it runs fully on GPU |
| 8× H200 (1,128 GB) | Q2_K GGUF (1,009.3 GB) | Just under our 90% line; KLX-IQ2_XXS has more headroom |
| 4× B300 (1,152 GB) | Q2_K GGUF (1,009.3 GB) | Official MXFP4 does not fit |
| 8× B300 (2,304 GB) | Official MXFP4 (1,561.3 GB) | vLLM's baseline setup |
Kimi K3.1 Pro vs Kimi K3: memory at a glance
| Kimi K3 | Kimi K3.1 Pro | |
|---|---|---|
| Official weights | 1,560.9 GB | 1,561.3 GB |
| 24 full-attention layers | Gated MLA | Gated DSA (sparse, top-2048) |
| KV per token (our BF16 estimate) | 27,648 bytes | 33,792 bytes |
| Smallest full GGUF we list | 466.4 GB (Unsloth UD-Q1_0) | 592.7 GB (KarLexAI KLX-IQ1_S) |
| Mainline llama.cpp | Unsloth uses its own fork | Text support merged Nov 6, 2026; vision still open |
Sources: our Kimi K3 page and the sources below.[3][13][14] Unsloth had not published a K3.1 Pro GGUF when we checked (its repo holds the safetensors only), so the low-bit range is thinner than for K3.[15]
How to run it
The model card recommends vLLM, SGLang and TokenSpeed.[2] vLLM's recipe (vLLM 0.34.0) runs the MXFP4 checkpoint with TP8 on two GB300 trays or one B300 node, or one MI355X node on AMD; its default preset is 4× GB300 NVL4 multi-node.[8]
For llama.cpp, text support for Kimi K3.1 Pro was merged on November 6, 2026 (PR #31779). Vision support was still an open pull request (#31980) on November 10.[13][14] Rule of thumb from Unsloth's Kimi K3 guide (see our Kimi K3 page): RAM + VRAM should be about the size of the file, or llama.cpp reads from disk and slows down a lot. See our MoE expert offload guide. We have not measured its speed.
The card sets thinking effort with reasoning_effort (low, high or max, default max) and says multi-turn chats must pass back the full assistant message, including reasoning_content.[2]
Cheapest GPUs to rent for Kimi K3.1 Pro
Four B300s hold the 2-bit Q2_K GGUF; eight B300s hold the official MXFP4 weights. On-demand per-GPU prices from Runpod (our price file, checked November 9, 2026; Community Cloud is cheaper but runs on shared hosts), times the GPU count:[12]
| GPU (Runpod (on-demand, as listed)) | VRAM | Price |
|---|---|---|
| 4× B300 (Community) | 1152 GB | $27.76/hr |
| 8× H200 (Community) | 1128 GB | $28.72/hr |
| 4× B300 | 1152 GB | $35.96/hr |
| 8× H200 | 1128 GB | $42.32/hr |
| 8× B300 (Community) | 2304 GB | $55.52/hr |
| 8× B300 | 2304 GB | $71.92/hr |
Prices checked on 2026-11-10. They change often, so confirm on the provider's page. Runpod lists per-GPU prices; the 4- and 8-GPU rows are that price times the GPU count. Whether a multi-GPU pod is available at any moment varies. Rent on Runpod Referral link
Run it in the cloud
| Provider | Option | Price |
|---|---|---|
| Novita AI Referral link | Model APIs (check if this model is listed) | see price |
| Runpod Referral link | Needs more than one GPU at MXFP4 (official) (about 1562 GB) | see price |
| Vast.ai Referral link | Rent a GPU: 4× B300 (Community) (1152 GB) | see price |
| DigitalOcean Affiliate partner | GPU Droplets (check current GPUs and prices on DigitalOcean) | see price |
Rent a GPU: Vast.ai Referral link · Runpod Referral link · DigitalOcean Affiliate partner · E2E Networks. Run it via API instead: Novita AI model APIs Referral link, or compare AI APIs.
We may earn from links marked Affiliate partner or Referral link. Disclosure.
Want to try your own setup? Open the calculator with a custom 2,304 GB setup (Kimi K3 is in the calculator; K3.1 Pro's weights are within 0.1% of it) and change the memory. See all GPU rental prices for more providers.
Frequently asked questions
How much VRAM does Kimi K3.1 Pro need?
About 1,561 GB (1.56 TB) for the official MXFP4 weights, plus about 0.28 GB for an 8K-token cache by our estimate.[4][3] That is eight 288 GB B300s. At 2 bits (Q2_K GGUF, 1,009.3 GB) eight H200s or four B300s are enough.[5]
Can I run Kimi K3.1 Pro locally?
Only on a very large machine. The smallest full build we found, KLX-IQ1_S, is 592.7 GB; you need about that much RAM + VRAM combined.[6] The pruned build is 475.5 GB but removes 75% of the experts.[7] No consumer GPU and no single Mac holds it.
Is Kimi K3.1 Pro bigger than Kimi K3?
Not in weights: 1,561.3 GB vs 1,560.9 GB.[4] The KV cache per token is about 22% larger by our estimate because the sparse-attention indexer stores an extra key, which matters only at very long context.[3]
Does llama.cpp support Kimi K3.1 Pro?
Text yes, since PR #31779 was merged on November 6, 2026. Image input was still in review (PR #31980) on November 10.[13][14]
Can I use Kimi K3.1 Pro commercially?
The Kimi K3.1 Pro License allows commercial use. A "Model as a Service" business with over $20 million in revenue over 12 months needs a separate agreement with Moonshot, and products with over 100 million monthly users or $20 million monthly revenue must show "Kimi K3.1-Pro" in the interface. Internal use is exempt from both.[16]
Weights + KV cache from real Hugging Face file sizes, 90% fit rule, every number sourced.
How we calculate + sources ⓘ
How we calculated
- Weights are the exact file sizes on Hugging Face, checked November 10, 2026, with multi-file builds added up.[4][5][6][7] The vision projector is not included.
- KV cache is our estimate from
config.json: 24 DSA layers × (512 latent + 64 position + 128 indexer values) × 2 bytes; the 69 linear-attention layers keep a fixed state instead.[3] Moonshot has not published a figure. - Device memory is from NVIDIA, Apple and Runpod spec and pricing pages. Multi-GPU rows add up memory and assume an even split.
- Rental prices are Runpod's listed on-demand per-GPU rates from our GPU price data (checked November 9, 2026), times the GPU count.[12]
- Not included: engine working buffers, the OS and display. These vary by engine and settings, so leave headroom.
Get fit alerts for your GPU
Join the fit-alerts waitlist
Alerts are not running yet. Join the waitlist and pick your card once; when alerts launch we will email you once to confirm, and only after you confirm will you get the first alerts. Unsubscribe any time.
Sources ⓘ
Sources
All sources checked on .
- Hugging Face, moonshotai/Kimi-K3.1-Pro (license, repo created November 2, 2026, downloads and likes; checked November 10, 2026). https://huggingface.co/moonshotai/Kimi-K3.1-Pro
- Kimi K3.1 Pro model card (2.8T total / 104B active, 1M context, 69 KDA + 24 Gated DSA layers, MXFP4 quantization-aware training, recommended engines, reasoning settings). https://huggingface.co/moonshotai/Kimi-K3.1-Pro/blob/main/README.md
- Hugging Face, config.json (93 layers, kda_layers and full_attn_layers, dsa_config index_head_dim 128 / index_topk 2048, kv_lora_rank 512, rope dim 64, MXFP4 quantization config). https://huggingface.co/moonshotai/Kimi-K3.1-Pro/blob/main/config.json
- Hugging Face, moonshotai/Kimi-K3.1-Pro file list (official MXFP4 safetensors, 1,561,293,160,568 bytes). https://huggingface.co/moonshotai/Kimi-K3.1-Pro/tree/main
- Hugging Face, DevQuasar/moonshotai.Kimi-K3.1-Pro-GGUF (MXFP4_MOE, Q2_K, mmproj; "VERY EXPERIMENTAL"). https://huggingface.co/DevQuasar/moonshotai.Kimi-K3.1-Pro-GGUF/tree/main
- Hugging Face, KarLexAI/Kimi-K3.1-Pro-GGUF (KLX-IQ1_S / IQ1_M / IQ2_XXS sizes, uploader's KL divergence and 8× H100 speed claims). https://huggingface.co/KarLexAI/Kimi-K3.1-Pro-GGUF
- Hugging Face, vllm-project/Kimi-K3.1-Pro-pruned75 (224 of 896 experts kept, GSM8K 43.67%, TP=4 on B300). https://huggingface.co/vllm-project/Kimi-K3.1-Pro-pruned75
- vLLM Recipes, moonshotai/Kimi-K3.1-Pro (TP8 on one B300 node or two GB300 trays, MI355X, DCP8 KV capacity, indexer-key cache). https://recipes.vllm.ai/moonshotai/Kimi-K3.1-Pro
- NVIDIA, H100 (80 GB). https://www.nvidia.com/en-us/data-center/h100/
- NVIDIA, H200 (141 GB). https://www.nvidia.com/en-us/data-center/h200/
- Apple, Mac Studio tech specs (up to 512 GB unified memory). https://www.apple.com/mac-studio/specs/
- Runpod, GPU pricing (B300 288 GB, B200 180 GB, H200 141 GB per-GPU on-demand rates; in our price file, last verified November 9, 2026). https://www.runpod.io/pricing
- llama.cpp PR #31779, "model: add Kimi-K3.1-Pro text model" (merged November 6, 2026 22:42 UTC). https://github.com/ggml-org/llama.cpp/pull/31779
- llama.cpp PR #31980, "mtmd: add kimi K3.1 vision" (open on November 10, 2026). https://github.com/ggml-org/llama.cpp/pull/31980
- Hugging Face, unsloth/Kimi-K3.1-Pro (safetensors only, 1,561.3 GB; checked November 10, 2026). https://huggingface.co/unsloth/Kimi-K3.1-Pro
- Kimi K3.1 Pro License. https://huggingface.co/moonshotai/Kimi-K3.1-Pro/blob/main/LICENSE
Last checked: