Kimi K3 Weights Are Out: What It Takes to Run Them (2026)

Moonshot published the Kimi K3 weights on July 27, 2026, and the honest answer changed. No Mac and no GPU runs this model: the smallest community quant on HuggingFace is 567GB, which is 55GB more than a maxed-out 512GB Mac Studio holds. What does run it is a used dual-socket EPYC server with 1TB of DDR4, and memory is the bulk of what it costs. The catch nobody mentions yet: as of July 28 the llama.cpp support is still an unmerged pull request, so the weights are ahead of the software.

What is Kimi K3?

Kimi K3 is Moonshot AI's flagship open-weight model, and its own model card calls it the world's first open 3T-class model. The published architecture is 2.8 trillion total parameters with 104 billion activated per token, 93 layers, and 896 experts of which 16 fire per token (Kimi K3 model card, 2026). It is natively multimodal, with a MoonViT-V2 vision encoder of 401M parameters, and carries a context window of 1,048,576 tokens.

One detail matters more than the headline size. Moonshot trained K3 with quantization-aware training using MXFP4 weights and MXFP8 activations, so the official checkpoint is already 4-bit. There is no FP16 release to shrink. The 96 safetensors shards in the repository total 1,560GB, and that is the starting point, not the worst case.

The license is a custom Kimi K3 License rather than MIT, which answers the open question from our July 21 preview of this release.

How good is Kimi K3 at coding?

On the independent vals.ai SWE-Bench Verified leaderboard, Kimi K3 resolves 93.40% of issues, ahead of most cloud models but behind Claude Opus 5 at 97.00% and DeepSeek V4 Pro 0813 at 96.40% (vals.ai, 2026). That is an open-weight model within 4 points of the best closed API. Our local vs cloud leaderboard tracks the same benchmark.

Moonshot's own card reports 88.3 on Terminal-Bench 2.1 and 42.0 on SWE-Marathon, both run on Moonshot's harness (Kimi K3 model card, 2026). Vendor-run figures deserve vendor-run treatment: they are claims, not independent results.

How much memory does Kimi K3 actually need?

Enough that the interesting question is capacity, not speed. These are real file sizes measured from the HuggingFace API on July 28, 2026, not estimates from a bytes-per-parameter formula:

Set that against what you can buy in one box:

The Mac Studio result is the one that surprises people. The largest Apple machine sold today falls 10% short of the most aggressive 1-bit quant, and that is before the KV cache. Only the REAP80 variant fits, and that build has 80% of its experts pruned away, so it is a different model wearing the K3 name. Treat its quality as unverified until someone benchmarks it.

What speed can you expect?

Decode speed on a mixture-of-experts model is bandwidth-bound, and you only read the active parameters each token. The arithmetic:

bytes per parameter = quant file size / 2.8T total params
read per token      = 104B active params x bytes per parameter
tok/s ceiling       = memory bandwidth / read per token

That gives about 34.7GB read per token at Q2_K and 21.2GB at IQ1_S. Against real memory bandwidth, the ceilings look like this. These are estimates from published bandwidth figures, not measurements, and real output lands well under any roofline:

Two caveats that matter more than the numbers. A dual-socket box splits memory across NUMA nodes, and inference engines rarely extract the full aggregate figure. And a 104B active-parameter forward pass on CPU cores is not free, so on a budget build compute, not bandwidth, may bind first.

The build that actually runs Kimi K3

The requirement is 1TB of RAM, and the cheapest honest path there is a previous-generation dual-socket EPYC platform. Server DDR4 costs far less per gigabyte than current DDR5, and the 2026 memory shortage moves prices fast, so check live listings before you order.

Disclosure: the links below are Amazon affiliate links. ModelFit earns a commission if you buy, at no extra cost to you.

Add the whole build to an Amazon cart. Amazon only adds parts that are in stock that day, so check every line in the cart against the table before you order.

Memory is the bulk of the cost. The 4TB drive is not optional: the Q2_K download alone is 929GB across 94 files, and you want room to hold a second build.

Two upgrades are worth the money in this order. Move to DDR4-3200 kits if the budget allows, since EPYC 7002 supports it and bandwidth is the binding constraint. Then add a single GPU for prompt processing, which is compute-bound rather than capacity-bound, so even a 16GB card helps on long prompts.

Why the expensive DDR5 build is worse

Here is the result that runs against intuition. A modern 12-channel DDR5 workstation delivers 35% more bandwidth, and it is the wrong buy for this model.

A 64GB DDR5-4800 ECC RDIMM (Samsung M321R8GA0BB0-CQK) costs several times what a 64GB DDR4 module does in the current shortage. Filling all 12 channels yields 768GB, before you add an EPYC 9355P and a board.

That build gets you 768GB, which holds IQ1_S at 567GB but cannot hold the 929GB Q2_K build. The DDR4 box holds a better quant than a DDR5 box whose memory alone costs several times as much. During a memory shortage, capacity per dollar beats bandwidth per dollar, and old server RAM is the arbitrage.

The software is not ready yet

Before anyone buys anything, check the state of the runtime. As of July 28, 2026, Kimi K3 text-model support in llama.cpp is an open pull request, #26185, opened July 27 and not merged. A companion change raising the expert cap to 1024, needed because K3 has 896 experts, was closed without merging. So the GGUF quants on HuggingFace run only on a patched branch, and Ollama cannot load K3 at all.

The supported paths today are the ones Moonshot lists on its card: vLLM, which publishes a K3 recipe, and SGLang. Both target GPU serving rather than CPU inference on a RAM box.

The sane sequence is to wait for #26185 to land, confirm someone reports real throughput on a CPU build, and buy after that. The RAM will still be expensive next month, and so far this hardware answers exactly one question.

What can you actually run instead?

The strongest open-weight coding score that fits consumer hardware is Qwen3.6-27B at 77.2% on SWE-Bench Verified (vals.ai, 2026). It runs on a 24GB Mac:

ollama run qwen3.6:27b

The general ladder, by memory:

For your exact machine, the ModelFit wizard or the hardware calculator will name the pick, or run npx @wecko-ai/modelfit in a terminal. The sizing logic is in our RAM guide.

Can you spend less and still run a strong coding model?

Yes. The strongest local coding score that fits consumer hardware is Qwen3.6-27B at 77.2% on SWE-Bench Verified, and it already runs on a 24GB Mac. If your machine is a desktop or a laptop with a spare M.2 or USB-C port, the cheapest real upgrade is storage, not memory: a 2TB NVMe drive like the Samsung 990 Pro 2TB or a 2TB external SSD like the Samsung T7 Shield 2TB holds a whole library of 20-32B models with room for quants. That path keeps the spend below a single memory kit of the K3 build, and every model in the ladder above runs through Ollama today.

If you want K3 specifically and not a build, rent it. An hour on a rented multi-GPU node costs less than one stick of the RAM above, and you can stop paying when the experiment ends.

Why does Kimi K3 still matter for local AI?

Because the open frontier keeps pulling the local frontier up. Frontier capability has historically reached laptop-class hardware with a lag that verified SWE-Bench data puts at roughly 11 months: How Far Behind Cloud AI Is Your Laptop?. A 93.4% SWE-Bench score with downloadable weights sets the ceiling that distillations and pruned variants inherit.

The REAP80 experiment is the near-term signal to watch. Cutting 80% of experts takes K3 from 1,560GB to 350GB, which is Mac Studio territory. If that kind of pruning holds quality, the path from a 2.8T model to something a workstation runs gets much shorter. When a K3-derived model lands that fits a 24GB or 48GB machine, it shows up on our leaderboard and in the open dataset.

FAQ

Can I run Kimi K3 on a Mac?

No. The smallest community quant of Kimi K3 is a 567GB IQ1_S GGUF, and the largest Mac sold, a 512GB Mac Studio, is 55GB short before any context memory. The only build that fits is REAP80 at 350GB, which has 80% of its experts pruned and is not equivalent to K3. No Apple machine currently holds the real model.

How much RAM do you need to run Kimi K3?

1TB of system memory is the practical floor for the 929GB Q2_K build, and 768GB works for the 567GB IQ1_S build if you keep context modest. The official MXFP4 checkpoint is 1,560GB and needs a multi-terabyte server. Every figure here is measured file size, not a bytes-per-parameter estimate.

What does a Kimi K3 machine cost?

A used dual-socket EPYC 7532 platform with 1TB of DDR4-2666 ECC memory, where memory is the bulk of the cost. The equivalent DDR5 build costs several times as much in memory alone and holds less, because 64GB DDR5 RDIMMs are far pricier than DDR4 in the current shortage.

Can Ollama run Kimi K3?

Not yet. Kimi K3 support in llama.cpp, which Ollama builds on, is an open pull request as of July 28, 2026 and has not been merged. The GGUF quants published on HuggingFace require that patched branch. The runtimes Moonshot supports today are vLLM and SGLang, both aimed at GPU serving.

Is Kimi K3 open source?

The weights are downloadable, so open weights is the accurate term. They ship under a custom Kimi K3 License rather than MIT or Apache, and Moonshot has not published training data. Its predecessor K2 used a Modified MIT license, so the terms tightened with this release.

Sources

• Kimi K3 model card, HuggingFace: https://huggingface.co/moonshotai/Kimi-K3
• HuggingFace model API, file sizes measured July 28, 2026: https://huggingface.co/api/models/moonshotai/Kimi-K3
• vals.ai SWE-Bench Verified leaderboard: https://www.vals.ai/benchmarks/swebench
• llama.cpp pull request 26185, Kimi-K3 text model: https://github.com/ggml-org/llama.cpp/pull/26185
• vLLM Kimi K3 recipe: https://recipes.vllm.ai/moonshotai/Kimi-K3
• Q2_K GGUF quant: https://huggingface.co/GrEarl/Kimi-K3-GGUF
• IQ1_S GGUF quant: https://huggingface.co/GrEarl/Kimi-K3-GGUF-IQ1_S
• REAP80 MLX build: https://huggingface.co/pipenetwork/Kimi-K3-REAP80-MLX-mxfp4-q8