Is Kimi K3 Open Source? License, Weights, GitHub, and What You Can Actually Use Today (2026)

2.8 trillion parameters. Open weights. Modified MIT license. The largest open model ever released.

Every one of those claims appeared in a different headline within 24 hours of Kimi K3's July 16, 2026 launch. Three of them are confirmed. One — the license — is expected but not yet officially published. And buried under the hype is a detail that changes the practical picture entirely: the weights are not available yet. They drop July 27, 2026. Today, K3 is API-only.

If you searched "kimi k3 open source" because you want to know whether you can download, self-host, fine-tune, or commercially deploy this model — this article gives you the honest, source-by-source answer. We tracked Moonshot AI's GitHub organization, cross-referenced their open-weight history across K2, K2.5, K2.6, and K2.7, verified the K3 timeline against Moonshot's official WeChat and English blog announcements, and estimated the hardware requirements based on K2.6 scaling and community analysis. By the end, you will know what is open today, what opens on July 27, what the license likely allows, and whether self-hosting K3 is realistic for your setup.

---

The Short Answer: Yes, But Not Yet — Check Here First

Before reading anything else, here is how to check whether K3 weights are available right now: go to github.com/MoonshotAI and look for a Kimi-K3 repository. If it exists, the weights are live. If the newest repo is still Kimi-K2.5 or Kimi-Linear, you are still in the waiting period. As of July 17, 2026, there is no K3 repo.

The answer is clear but the timeline matters. To understand why Moonshot delayed the weights by 11 days, and what to expect when they arrive, you need context on how they have handled every previous open release.

---

Moonshot's Open-Source Track Record: Every Release So Far

Moonshot AI has open-sourced more than most frontier AI labs. Here is the complete inventory of what they have released publicly as of July 2026:

Models on GitHub (github.com/MoonshotAI)

What Kimi-Linear tells us about K3

Kimi-Linear deserves special attention because it is already fully open — code, paper, and model checkpoints — and it is the technology that makes K3's 1-million-token context window possible.

Kimi-Linear introduced Kimi Delta Attention (KDA), a gated linear attention mechanism that reduces KV cache by up to 75% and speeds up decoding up to 6× for long contexts compared to standard full attention. The 48B-parameter Kimi-Linear model (3B active) was trained on 5.7 trillion tokens and supports 1M-token context natively.

K3 evolved this technology. The official K3 tech blog describes its attention mechanism as KDA with Attention Residuals (AttnRes) — a direct descendant of the Kimi-Linear architecture. This means the core innovation behind K3's long-context capability is already open, reviewed, and reproducible. The model weights are what is missing.

Moonshot's track record makes it clear they intend to release K3 openly. But "open" covers a spectrum — from MIT (do anything) to heavily restricted community licenses. The license Moonshot picks for K3 determines whether you can build a business on it.

---

The Modified MIT License: What You Can and Cannot Build With K3

Every K2-family model has shipped under a Modified MIT License. Based on the consistent pattern across K2, K2.5, K2.6, and K2.7 Code, and multiple early reports describing K3 as "Modified MIT," this is what to expect.

What the Modified MIT license typically allows

• Commercial use: Yes — build products, sell services, deploy to customers.
• Modification: Yes — fine-tune, distill, merge, quantize.
• Distribution: Yes — share weights, host for others, bundle in applications.
• Attribution: Required — you must include the original license notice.

What it restricts

• Synthetic data clause: Text generated by the model is not considered part of the model itself. However, K2's Modified MIT license explicitly states that the license does not apply to synthetic data or models trained on K2-generated synthetic data. This means you cannot claim the same license terms for a new model trained on K2 output.
• MAU clause (K2.7 precedent): K2.7 Code added a monthly-active-user threshold for large commercial deployments. If K3 follows this pattern, deployments above a certain user count may require a separate commercial agreement.

What is NOT yet confirmed for K3

• The exact license text has not been published. Do not make deployment commitments based on the K2 license — read the K3 license when it drops.
• Whether the MAU clause carries over from K2.7 or changes. If your application serves more than 100K monthly active users, flag this with your legal team now.
• Whether there are additional use-case restrictions. Some open-weight models from Chinese labs add explicit prohibitions on military, surveillance, or disinformation applications. K2's Modified MIT did not include such clauses, but K3 may differ given increased regulatory scrutiny in 2026.
• Whether fine-tuned derivatives inherit the same license or require separate terms.

The license determines what you are allowed to do. The hardware determines what you are able to do. Those are very different constraints.

---

Self-Hosting K3: Why 2.8T Parameters Changes Everything

K3 is 2.8 trillion parameters in a Mixture-of-Experts architecture with 896 experts, 16 active per token, and roughly 50 billion active parameters per forward pass. Moonshot trained it with MXFP4 quantization-aware training from the supervised fine-tuning stage onward, using MXFP4 weights with MXFP8 activations.

Here is what that means for running it locally:

Estimated weight file sizes

K2.6 shipped as a 594 GB download on HuggingFace using INT4 for MoE expert weights and BF16 for everything else. K3 will likely follow a similar mixed-precision format, putting the practical download in the 1.5–1.7 TB range.

Hardware tiers for inference

The honest assessment: K3 is not a local model. Not for consumers, not for most startups, not even for well-funded teams without existing GPU clusters. The 50B active parameters per token seem manageable (comparable to a large dense model), but the 2.8T total parameters must reside in memory — and MoE routing means the system needs fast access to all 896 expert weight matrices, not just the 16 active ones.

The tooling gap

Even if you have the hardware, you cannot run K3 locally on day one. K3 introduces two architectural components that existing open-source inference engines do not yet support:

• Kimi Delta Attention (KDA): Not in llama.cpp, Ollama, or LM Studio as of July 2026.
• Stable LatentMoE routing: Requires custom kernel support.

The Kimi-Linear codebase provides a reference implementation for KDA, and Moonshot has contributed KDA kernels to the FLA (Flash Linear Attention) library. But integration into mainstream tools like vLLM, llama.cpp, and text-generation-inference will take time — likely weeks to months after the weight release.

Three mistakes people will make on July 27

Based on what happened when K2.6 dropped (community posts, failed deployments, wasted cloud spend):

1. Downloading BF16 weights on insufficient hardware. K2.6's BF16 was 594 GB. K3's BF16 will be 5+ TB. If you start a download without confirming your storage and memory can handle it, you will waste hours and bandwidth. Check your disk space and total system memory against the weight file size before downloading.

2. Assuming vLLM or llama.cpp will work immediately. K3's KDA attention requires custom kernels. Expect the first community-compatible inference scripts to come from Moonshot's own repo or the FLA library, not from mainline vLLM. Check the K3 repo's README for supported inference backends before filing GitHub issues.

3. Running quantized weights without verifying quality. Community quantizations (GGUF, AWQ, GPTQ) will appear within hours. But a 2.8T MoE model quantized to 1.8-bit is uncharted territory — quality degradation is likely more severe than for smaller models. Run your own eval before deploying any community quant to production.

Hardware and pitfalls are covered. The remaining question is strategic: given the 10-day wait, the tooling gap, and the cost reality, should you even pursue self-hosting — or is the API the better path?

---

API Now vs. Open Weights Later: Decision Framework

This is the question most teams searching "kimi k3 open source" actually need answered. The weights open on July 27, but that does not mean self-hosting becomes practical on July 27.

Break-even analysis: API vs self-hosting

Based on Moonshot's pricing ($3.00/1M input, $15.00/1M output) and estimated self-hosting costs:

• Hardware amortization: A minimal viable K3 cluster (8× A100 80GB) costs roughly $15,000–$20,000/month in cloud rental.
• Break-even point: Approximately 1–1.5 million output tokens per day (30–45M/month) before self-hosting becomes cheaper than the API.
• Reality check: Most teams evaluating K3 today process far less than 1M output tokens daily. For them, the API is not just more convenient — it is cheaper.

Whether you choose API or open weights, you do not have to wait idle until July 27. Moonshot's existing open-source ecosystem already gives you tools to start building and testing.

---

What You Can Download and Run Right Now

While K3 weights are not yet available, Moonshot's existing open-source ecosystem gives you meaningful tools to work with right now:

1. Kimi-Linear (MIT License)

• Repository: github.com/MoonshotAI/Kimi-Linear
• What's included: Code, paper, 48B model checkpoints (Base + Instruct)
• Why it matters: The attention architecture behind K3's 1M context. If you are researching linear attention or building long-context applications, this is the most relevant open artifact.

2. K2.6 / K2.7 Code (Modified MIT)

• Available on HuggingFace: moonshotai/Kimi-K2.6, moonshotai/Kimi-K2.7-Code
• Why it matters: Same MoE architecture family as K3, same license type, well-supported in vLLM and Unsloth. If you need a Kimi model running locally today, K2.6 (594 GB) or K2.7 Code are your options.

3. K3 via API (no weights needed)

• Endpoints: platform.kimi.ai (international), platform.moonshot.cn (China), OpenRouter (moonshotai/kimi-k3)
• Why it matters: Full K3 capability at $3.00/$15.00 per million tokens. No hardware requirements beyond an API key.

Those are the options today. The landscape changes on July 27 — and possibly before, depending on five signals worth monitoring.

---

Five Signals to Watch Before July 27

The open-weight story is still developing. These are the signals that will determine whether K3 becomes practically useful as an open model:

1. The license file. When the K3 GitHub repo goes live, the first thing to check is whether the Modified MIT license includes a MAU clause like K2.7 Code. This determines commercial deployment terms.

2. Model format. Whether Moonshot ships BF16 + INT4 (like K2.6), native MXFP4, or both. The format determines which inference engines can load K3 on day one.

3. vLLM and llama.cpp support. KDA kernels need to be integrated into mainstream inference tools. Watch the FLA library repo and the vLLM changelog for K3-related PRs.

4. Community quantization. GGUF and other quantization formats will follow quickly after weights drop — but quality at extreme compression (1.8-bit and below) for a 2.8T model is uncharted territory.

5. Technical report. Moonshot has stated that "further details on the architecture, training, and evaluations will be released alongside the technical report." This report will clarify training data scope, benchmark methodology, and architectural decisions that affect fine-tuning.

Those are the signals for people tracking the release actively. The questions below cover what most people searching "kimi k3 open source" want answered quickly.

---

Frequently Asked Questions

Is Kimi K3 open source? K3 is open-weight, not fully open-source in the OSI sense. The trained model weights will be freely downloadable under a Modified MIT license. The training data and full training pipeline are not released.

When can I download K3 weights? July 27, 2026. Moonshot confirmed this date in their official launch announcements on WeChat and their English blog.

What license will K3 use? Expected to be Modified MIT, the same license family used for K2, K2.5, K2.6, and K2.7 Code. This allows commercial use with attribution. The exact license text is not published until the weights drop.

Can I run K3 on my local machine? Almost certainly not on consumer hardware. K3 requires at minimum ~1.5 TB of memory for the smallest practical format. Even aggressive quantization does not bring it within range of a single GPU or a high-end Mac Studio.

Is Kimi K3 on GitHub? Not yet. Moonshot's GitHub organization (github.com/MoonshotAI) hosts K2, K2.5, Kimi-Linear, and Kimi-VL. A K3 repo is expected on or before July 27, 2026.

Can I fine-tune K3? Once the weights are available, yes — assuming the license permits it (Modified MIT allows modification). However, fine-tuning a 2.8T MoE model requires significant compute resources. Most teams will fine-tune using LoRA or similar parameter-efficient methods rather than full fine-tuning.

How does K3 compare to other open models? At 2.8T total parameters, K3 is the largest open-weight model as of July 2026. For comparison: DeepSeek V4 Pro is 1.6T, GLM-5.2 is ~1.5T, and Llama 4 Behemoth is 2T. K3 leads in total parameter count, but active parameters per token (~50B) are comparable to much smaller models.

---

Core Summary

K3 is open-weight and will be the largest publicly downloadable model when weights arrive on July 27, 2026 — but "open" does not mean "easy to run."

• Status today: API-only. Weights in 10 days. No K3 repo on GitHub yet.
• License: Modified MIT expected. Commercial use with attribution, likely with a synthetic data clause and possibly a MAU threshold.
• Self-hosting reality: Minimum ~1.5 TB memory for the smallest practical format. Consumer and prosumer hardware cannot run it. Enterprise clusters can.
• Already open: Kimi-Linear (the attention architecture behind K3's 1M context) is fully open under MIT. K2.6 and K2.7 Code are available now under Modified MIT.
• Tooling gap: Even with the right hardware, mainstream inference engines (llama.cpp, vLLM) need weeks to months to integrate K3's novel architecture.

The concrete next step depends on your timeline. If you need K3 capability now, start with the API at platform.kimi.ai — it takes 5 minutes. If you are planning for self-hosted deployment, start by running K2.6 on your infrastructure to validate your hardware and pipeline, then swap in K3 weights when they arrive and tooling catches up. Do not buy hardware for K3 until you have confirmed that your inference stack supports KDA — the weights alone are not enough.