Kimi K3 on Hugging Face: Open Weights Status, Download Timeline, and How to Prepare (July 2026)

"Where do I download Kimi K3?"

Nowhere. Not yet.

K3 launched on July 16, 2026. The API is live. The chat interface is live. But if you go to Moonshot's HuggingFace org right now, the newest model is still K2.7 Code. The K3 repo does not exist. Open weights are confirmed for July 27, 2026 — ten days after launch.

If you searched "kimi k3 huggingface" hoping to find a download link, this article saves you the confusion — and the wasted time clicking through Instagram posts that say "download K3 on Hugging Face today" when they actually mean K2.6. We tracked Moonshot AI's HuggingFace org, cross-referenced the open-weight timeline against their K2.6 and K2.7 releases, and compiled everything you need to prepare your infrastructure before the weights drop. Sources: Moonshot's official announcements, the moonshotai HuggingFace org page, BenchLM model tracker, and r/LocalLLaMA community reports.

By the end, you will know exactly when to expect the download, what file sizes and formats to plan for, what hardware you actually need (spoiler: more than you think), and what you can run locally today while you wait.

Current Status: What Is and Isn't Available

If you see social media posts claiming "download K3 weights on Hugging Face today," they are either confused or referring to K2.6/K2.7 — not K3. The official K3 HuggingFace repo has not been created as of this writing.

So what is actually on Moonshot's HuggingFace org right now — and what does it tell us about what K3 will look like when it arrives?

Moonshot AI's HuggingFace Org: 6 Models, Zero Named "K3"

Moonshot publishes models under huggingface.co/moonshotai. Here is what the org currently contains — this is the foundation K3 will build on:

K2.6 at 1.46 million downloads is by far the most popular — it became the go-to open-weight agentic model after its May release. K2.7 Code at 781K downloads in one month shows strong coding-community adoption.

Every K2 release followed the same pattern: official Safetensors on HuggingFace, followed by community GGUF quantizations within days (42 community quantization variants for K2.6 alone). K3 will almost certainly follow this pattern.

The K2.6 model card gives us a detailed template for what K3's HuggingFace page will probably contain. Here is what to expect.

What the K3 Model Card Will Probably Look Like

Based on K2.6's model card structure and K3's confirmed specs, here is what the K3 HuggingFace page will likely include:

Architecture Details

The jump from 384 experts (8 active) to 896 experts (16 active) means each token routes through twice as many experts as K2.6 — which partly explains both the quality improvement and the larger weight files.

Expected File Sizes

Multiple sources report K3 weights at 594 GB in BF16 format. For context:

The 594 GB figure for K3 may seem surprisingly close to K2.6's size despite having nearly 3× the parameters. This is likely due to MXFP4 weights — Moonshot used quantization-aware training with MXFP4 weights and MXFP8 activations, meaning the model was designed from the start to be served at reduced precision without the accuracy loss you get from post-training quantization.

Expected Formats and Serving Frameworks

Based on K2.6 precedent:

• Day-one official: Safetensors (BF16 or MXFP4 native)
• Supported inference engines: vLLM, SGLang, KTransformers
• Community quantizations (days/weeks later): GGUF for llama.cpp, Ollama, LM Studio, Jan
• Moonshot has contributed a vLLM KDA prefill cache implementation that should ship alongside or shortly after the weights

Knowing the file sizes and formats is useful for planning. But the harder question is whether your hardware can actually run the model.

Hardware Requirements: Why Most People Cannot Run K3 Locally

Short answer: probably not on consumer hardware. Long answer: here is how to check.

The key constraint is that even at reduced precision, K3 needs to load ~594 GB of weights into memory. A single H100 has 80 GB of VRAM. You need a minimum of 8× H100s just to load the model — before you account for KV cache overhead for the context window.

What about GGUF quantizations? Community Q4 (4-bit) quantizations will reduce the file size to roughly 300–400 GB, but that still exceeds consumer hardware. Even a fully loaded Mac Studio M4 Ultra with 512 GB unified memory would be running at the absolute edge with Q4 K3, with severely limited context length and very slow generation speed.

If your hardware does qualify, the next ten days are preparation time — not waiting time.

How to Prepare Before July 27: A 4-Step Staging Checklist

You do not have to wait passively. Here is a staging checklist for teams planning to self-host K3:

1. Set up your inference environment now (30 minutes).

python -m venv ~/vllm-kimi-staging
source ~/vllm-kimi-staging/bin/activate
pip install -U vllm
huggingface-cli login

Test your setup with K2.7 Code — it uses the same serving stack:

vllm serve moonshotai/Kimi-K2.7-Code \
  --tensor-parallel-size 4 \
  --max-model-len 131072 \
  --trust-remote-code

If this works on your hardware, you know your infrastructure can handle the K3 serving pipeline. The model ID will change but the pattern is the same.

2. Reserve storage. Plan for multiple terabytes — the BF16 shards (~594 GB) plus KV cache, plus any quantized copies you want to keep. HuggingFace downloads also need temporary space.

3. Pin your deployment to the official repo. When K3 drops, the repo will be something like moonshotai/Kimi-K3-Instruct. Do not hardcode this into CI/Terraform before the actual repo name is confirmed — wait for the official announcement and pin to a specific commit hash.

4. Prepare your test suite. Write down the 3–5 prompts that represent your hardest real-world tasks. Run them on K3 API today ($3.00/MTok input is cheap for a few test calls). Save the outputs. On July 27, run the identical prompts on your local deployment and compare — this tells you whether local performance matches API quality.

While you stage your K3 infrastructure, you might need local inference right now. K2.7 Code fills that gap.

K2.7 Code: What You Can Actually Run Locally Today

If you need local Kimi inference today, K2.7 Code is the production-ready option:

K2.7 scored 81.1% on MCP Mark — meaning it handles tool-calling agent loops well. For teams building agentic coding workflows that need to run on-premises for security or latency reasons, K2.7 is a genuine production option, not just a placeholder.

The upgrade path is clear: run K2.7 locally now, test K3 via API, switch to local K3 after July 27 if your hardware supports it.

With K2.7 for local and K3 API for cloud, the question becomes: which path is right for your specific situation?

API vs. Open Weights: Which Path Fits Your Situation

The hybrid approach — K2.7 local plus K3 API — appears in multiple rows because it is genuinely the most practical setup for most teams. But if you are considering full K3 self-hosting, the next question is whether the cost makes sense.

Self-Hosting Cost vs. API: When Does Local K3 Break Even?

Before committing to self-hosting, do the math. Here is a rough comparison:

The break-even point depends on your daily token volume. At $15/MTok output, a team generating 1 million output tokens per day pays ~$450/month in API costs. An 8× H100 cloud instance costs ~$20,000/month. You need roughly 40+ million output tokens per day before self-hosting is cheaper than the API — and that calculation ignores engineering time for deployment, monitoring, and maintenance.

After July 27: Timeline, Community Ports, and Day-One Cautions

The weight release is not the end of the story. Based on the K2.6 release cycle, here is what to expect:

K2.6 accumulated 42 community quantization variants and 1.46 million downloads within two months of release. If K3 follows a similar trajectory, community support will build fast — but the first week after release will be experimental.

Day-one caution: Pin your deployment to a specific commit hash from the official moonshotai repo. Do not pull from third-party quantization repos without verifying provenance. The first community GGUF uploads after a major release sometimes contain errors or incomplete conversions — wait for downloads to accumulate and community verification before trusting any community quantization for production.

FAQ

Is Kimi K3 available on Hugging Face?

No. As of July 17, 2026, there is no Kimi K3 repository on HuggingFace. Open weights are confirmed for July 27, 2026, under Moonshot AI's org (huggingface.co/moonshotai). K2.6 and K2.7 Code are available now.

Where will I download Kimi K3 model weights?

The official source will be Moonshot AI's HuggingFace organization at huggingface.co/moonshotai. The repo name is not confirmed yet — expect something like Kimi-K3 or Kimi-K3-Instruct. Watch for the official announcement on July 27.

How big are the Kimi K3 model files?

Reported at approximately 594 GB in BF16 format. Community GGUF quantizations (Q4) will likely reduce this to 300–400 GB. You need multiple terabytes of free storage for the download plus inference cache.

Can I run Kimi K3 locally on my desktop?

Not the full model. K3 at 2.8T parameters requires a minimum of 4–8× H100 80 GB GPUs for experimental use. Consumer hardware (RTX 4090, Mac Studio) cannot load the model even in quantized form. For local desktop inference, use K2.7 Code instead — it runs on a single 24 GB GPU with quantization.

What license will Kimi K3 use?

Expected to be Modified MIT, the same license used by K2.6, K2.7 Code, and previous Kimi models. Exact terms will be confirmed in the model card on July 27. Do not make license-dependent decisions until you read the official card.

Will there be GGUF quantizations of Kimi K3?

Not officially from Moonshot — they publish in Safetensors format. Community quantizations (GGUF for llama.cpp, Ollama, LM Studio) typically appear days to weeks after official weight releases. K2.6 has 42+ community quantization variants as reference.

How does K3 compare to K2.6 on HuggingFace?

K2.6 has 1T total parameters (32B active, 384 experts, 8 active per token). K3 has 2.8T total parameters (896 experts, 16 active per token). K3 also uses Kimi Delta Attention instead of MLA, supports 1M context instead of 256K, and includes native multimodal support. The weight file is larger (~594 GB vs ~550 GB) but not proportionally to the parameter increase, thanks to MXFP4 quantization-aware training.

Should I wait for K3 weights or use the API?

If you need K3-level performance today, use the API ($3.00/MTok input, $15.00/MTok output). If you need local inference today, use K2.7 Code. If you specifically need K3 local for compliance, security, or fine-tuning, wait for July 27 and prepare your infrastructure now using the staging steps in this article.

Bottom Line

The simplest version of this article: Kimi K3 open weights are not on HuggingFace yet. They arrive July 27. The model is 594 GB. You need enterprise GPUs to run it locally.

Everything else is preparation and context.

If you are planning to self-host K3, the ten days between now and July 27 are not idle time. Set up vLLM. Test with K2.7. Run your hardest prompts against the K3 API to establish a quality baseline. Reserve storage and GPU allocation. When the weights drop, you want to be deploying — not debugging your environment.

If local inference is not your priority, the API is live today at kimi.com (free tier) or platform.moonshot.cn (pay-per-token). You can evaluate K3 right now without waiting for any download.

Bookmark huggingface.co/moonshotai. That page is where K3 weights will appear. Check it on July 27.