Can You Run Kimi K3 Locally?

Updated July 28, 2026 — one day after the weights dropped. The community has already shrunk Kimi K3 by 4.5×, from 1,561 GB down to 350 GB. We measured every build ourselves — see what 24 hours of compression achieved, and why it still isn't enough. All figures on this page are measured from the published files, not estimated.

Kimi K3, from Moonshot AI, is the biggest open-weight model ever released: a 2.8-trillion-parameter Mixture-of-Experts model that early third-party testing ranked competitively with the best closed systems. Announced on July 16 and opened on July 27, 2026, it immediately drew "DeepSeek shock" comparisons.

So: can you run Kimi K3 on your own machine? Now that the files are public, we can answer with real numbers instead of guesses. The short version: no — and it isn't close.

The real download size: 1,561 GB, not 594 GB

Most coverage ahead of the release quoted a download of around 594 GB for the native MXFP4 weights. That figure does not match the published files.

We summed the size of every weight file in the official repository via the Hugging Face API on July 27, 2026:

That is roughly 2.6× the widely reported figure, and it is exactly what you would expect: 2.8 trillion parameters stored at 4 bits is about 1.4 TB of raw weights, plus scale factors and metadata. If you were budgeting disk space based on the 594 GB number, you need more than twice that.

The first GGUF build: still ~965 GB to run

Within hours of the release, the first community GGUF conversion appeared — a Q2_K (roughly 2-bit) build split across 96 files. Even that extreme quantization doesn't bring K3 anywhere near a desktop:

Our calculator reads the real GGUF file sizes and confirms the model at 2,779.93 billion parameters, needing about 965 GB of combined memory at Q2_K. For scale, that is roughly 30× an RTX 5090's 32 GB, and about 7.5× a 128 GB unified-memory machine — the class of hardware that can just barely run Tencent's Hy3 at 1-bit (~87 GB).

24 hours later: how small did the community get it?

Within a day of the weights going public, quantizers and pruners went to work. We measured every build we could find on July 28, 2026, by summing the published weight files:

That is a remarkable engineering effort in one day — a 4.5× reduction. Our calculator puts the 1-bit IQ1_S build at about 554 GB of memory to actually run, still with offloading.

And yet the conclusion doesn't change. The smallest build anyone has produced, at 350 GB, is still:

• 11× too large for an RTX 5090's 32 GB;
• 2.7× too large for a 128 GB unified-memory machine — the class of hardware that just manages Tencent's Hy3 at 1-bit (~87 GB).

Interest is not in doubt: the official repository went from roughly 5,000 to nearly 6,000 likes in the hours after opening, and mirrors, tokenizer ports and re-quantizations keep appearing. If a genuinely consumer-sized K3 derivative ever lands, we'll measure it and add it here.

So who can actually run it?

Not you, unless you own a server rack. Running K3 means multi-node GPU clusters — think eight or more 80 GB accelerators just to hold a heavily quantized copy, and considerably more for the native weights at usable speed. No consumer GPU, no Mac Studio, no Strix Halo box comes close.

What "open weights" buys here is not home use. It's the ability for companies, labs and cloud providers to inspect, fine-tune and self-host the model on their own infrastructure instead of renting it through an API — which is the real story behind the market reaction.

What the architecture tells us

The published config.json shows a model built for long-context efficiency rather than desktop friendliness:

• 93 transformer layers, hidden size 7,168, 96 attention heads.
• Multi-head Latent Attention (kv_lora_rank: 512) — a compressed KV cache design, the same family of trick DeepSeek uses to keep long-context memory manageable.
• 1,048,576-token context (1M) and a 163,840-token vocabulary.
• Multimodal: the model class is registered for image-text-to-text input.

The MLA design means the KV cache grows far more slowly than a naive attention model of this size — but with ~965 GB of weights to load first, that efficiency doesn't rescue local use.

A note on the licence

Several outlets described the release as Apache 2.0. The repository does not say that. The published LICENSE file is a custom "Kimi K3 License" from Moonshot AI, and Hugging Face tags the model as license:other. The text is permissive in tone — it grants use "without restriction" — but if licensing matters for your use case, read the actual file rather than relying on the Apache 2.0 shorthand.

Which Kimi models CAN you run locally?

Moonshot also ships much smaller open-weight Kimi models that do fit real hardware, and they're available as GGUF today:

• Kimi-Linear-48B — a 48B Mixture-of-Experts model with only ~3B active parameters, so it's fast. MIT licensed, 1M context. Its hybrid attention keeps the KV cache tiny, so it runs on a 24 GB GPU at Q2_K using only about 17.2 GB of VRAM — with room for higher quality on larger cards.
• Kimi K2.6 / K2.7-Code and various Kimi distills — a range of sizes for different GPUs.

How to check what fits your GPU

Memory needs depend on model size, quantization and context length. Search any Kimi model to see its exact RAM/VRAM per quantization, or pick your graphics card to see what fits. New to quantization? Read GGUF quantization explained and the best LLM for your VRAM.

The bottom line

Kimi K3's weights are genuinely open as of July 27, 2026 — and genuinely enormous: 1,561 GB native, and still 350 GB in the most aggressively pruned-and-quantized build the community produced in the first 24 hours. It is a landmark release for organisations that can host it, and out of reach for everyone else. If you want Kimi on your own hardware today, Kimi-Linear-48B is the one to try. Check exactly what your PC can run.