Every DeepSeek Model, and What Is Really Open

Every DeepSeek model from 2023 to 2026 with its size, context and license, and exactly what you can download, run or rebuild yourself.

On 20 January 2025, a small lab in Hangzhou put a reasoning model with 671 billion numbers in it on a public website. Anyone could download it. The license was MIT, one of the shortest and most permissive licenses in common use. It allowed commercial use, changes, and even training other models on its answers.

That model was DeepSeek-R1. Its release started a long argument about what "open" means for an AI model. Since then, DeepSeek has put more than 100 model repositories on Hugging Face and 46 public code repositories on GitHub. Yet you cannot download the program that trained any of its main models, or the data it was trained on.

This part is a map. It lists every DeepSeek model from 2023 to November 2026, with its size, its context length and its license. Then it takes the word "open" apart, piece by piece: weights, code to run the model, code to train it, training data, papers and infrastructure. At the end you will know which model to look at for which job. You will also know exactly what you can download, what you can run, and what you can never rebuild from public material.

The lab behind the models

DeepSeek is a Chinese AI company. Its legal name, from its own license file, is Hangzhou DeepSeek Artificial Intelligence Fundamental Technology Research Co., Ltd. Its Hugging Face page says only that it was "founded in 2023" and is "dedicated to making AGI a reality". Its founder and CEO is Liang Wenfeng, who also appears as an author on its papers.

DeepSeek grew out of High-Flyer, a Chinese quantitative hedge fund that Liang co-founded. A quantitative fund trades with computer models, so it already owned many GPUs before large language models became popular. DeepSeek's own papers confirm the link: the Fire-Flyer paper thanks "our colleagues at DeepSeek-AI and High-Flyer Quant".

The clusters have names. Fire-Flyer 1 was built in 2019; DeepSeek's papers mention "our Fire-Flyer 1 experiments" but give no size for it. Fire-Flyer 2 is described in detail, in a paper presented at the SC24 supercomputing conference.

The V3 paper names a different cluster: 2,048 NVIDIA H800 GPUs. DeepSeek's later hardware paper notes that the H800's links between GPUs run at 400 GB/s, against 900 GB/s on the H100. Part 3 covers that training run.

Two ideas you need for the catalog

The catalog below rests on two ideas. Later parts go deep into each one.

The first is the most important for reading DeepSeek's numbers. An older model is dense: every parameter works on every token. A newer DeepSeek model is a mixture of experts.

Think of a hospital. A dense model is one doctor who must know everything and sees every patient. An MoE model is a hospital with 256 specialists and a receptionist. Each patient sees the receptionist, a family doctor (the shared expert) and 8 specialists. The hospital holds far more knowledge than one doctor, but each patient costs only a few visits.

Dense model: every weight works on every tokenDeepSeek-V3 MoE layer: 1 shared + 8 of 256 routed expertstokenone big feed-forward block(all of it is used)DeepSeek LLM 67B: all 67B weights work on each token.tokensharedexpertrouter256 routed experts (16 x 16)Counted from the V3 config: 37.6B of671B weights work on each token.
A dense model sends each token through all of its weights. A DeepSeek-V3 mixture-of-experts layer sends each token to 1 shared expert and 8 of 256 routed experts, so most of the 671B weights are idle for any one token.

This gives the second idea: every MoE model has two sizes.

How 671B becomes 37B

The two sizes follow from a simple count. Split the model into the part that always runs and the expert part.

The always-on part holds attention, the word embeddings, the output layer, the first few dense layers and the routers. The expert part holds many experts in each MoE layer, and a token uses only a few of them.

Ntotal=Nalways+(E+s) P LmoeN_{\text{total}} = N_{\text{always}} + (E + s)\, P\, L_{\text{moe}}

Nactive=Nalways+(k+s) P LmoeN_{\text{active}} = N_{\text{always}} + (k + s)\, P\, L_{\text{moe}}

Read them left to right. NalwaysN_{\text{always}} is the number of parameters that every token uses. EE is the number of routed experts in one MoE layer, and kk is how many of them the router picks per token. ss is the number of shared experts. PP is the size of one expert, and LmoeL_{\text{moe}} is the number of MoE layers.

A tiny example first. Take a model with 10 always-on parameters, 2 MoE layers, and 4 routed experts of 5 parameters each, with no shared expert. The router picks 1 expert per token. Total: 10+4×5×2=5010 + 4 \times 5 \times 2 = 50. Active: 10+1×5×2=2010 + 1 \times 5 \times 2 = 20. The model stores 50 numbers but each token touches 20.

Now the real DeepSeek-V3, with values from its config.json file. One expert has three weight matrices of size 7168×20487168 \times 2048, so P=3×7168×2048=44,040,192P = 3 \times 7168 \times 2048 = 44{,}040{,}192. There are E=256E = 256 routed experts, s=1s = 1 shared expert, k=8k = 8, and Lmoe=58L_{\text{moe}} = 58 MoE layers (61 layers, of which the first 3 are dense). The expert part is 257×44.04M×58=656.5B257 \times 44.04\text{M} \times 58 = 656.5\text{B} in total, but only 9×44.04M×58=23.0B9 \times 44.04\text{M} \times 58 = 23.0\text{B} per token. The always-on part is about 14.6B. So the total is about 671B and the active count is about 37.6B.

The paper says "671B total parameters with 37B activated for each token", which matches.

The assumption under the formula is that every token uses the same number of experts, kk, in every MoE layer. That holds for V2 and V3. In V4.1 it breaks in an interesting way, as the table below shows.

Every model, in order

DeepSeek has released a model, an update or a paper almost every month since late 2023. The timeline below shows only the main line. The specialised models come in the next section.

202420252026DeepSeek License (use restrictions)MIT for R1 at once; for the V3 line from V3-0324Weight license of the flagship models. The first V3 repo still carries the DeepSeek License.LLM 67Bdense 67BV2236B / 21BV2.5236B / 21BV3671B / 37BR1671B / 37BV3-0324MIT nowR1-0528671B / 37BV3.1think + non-thinkV3.2-Expsparse attentionV3.2671B / 37BV4 previewPro 1.6T/49B, Flash 284B/13BV4-Flash-0731V4-Pro-0813V4.1-Flash552B + 196B / 16BMain DeepSeek language models (total / active parameters)
The main DeepSeek language models from November 2023 to September 2026, with total and active parameters. The band underneath shows the weight license of the flagship models: the DeepSeek License until R1, then MIT.

2023: a dense start

DeepSeek's first public models were DeepSeek-Coder and DeepSeek LLM. Coder, a set of code models from 1.3B to 33B, appeared in late October and early November 2023. LLM 7B and 67B followed on 29 November 2023. Both were dense models with the same layout as Meta's LLaMA. The 67B model was trained on 2 trillion tokens of English and Chinese text.

The DeepSeek LLM paper states its open stance in one sentence.

2024: experts, latent attention and V3

In January 2024 came DeepSeekMoE 16B, the first DeepSeek mixture of experts. It has 16.4B parameters and uses about 2.8B per token. Its paper introduced two ideas that every later main model kept. One is many small experts instead of a few big ones; the other is shared experts for every token. Part 2 explains both.

In February came DeepSeekMath 7B. It is small, but its paper introduced GRPO, the reinforcement learning method behind R1 a year later. In March came DeepSeek-VL, the first vision-language model.

In May 2024, DeepSeek-V2 joined the two new ideas into one large model.

V2 was too big for most researchers to run. So DeepSeek also released a small sibling with the same design.

The rest of 2024 filled in the line. DeepSeek-Coder-V2 (June) continued training a V2 checkpoint on code. DeepSeek-V2.5 (September) merged the chat and code models into one. Janus (October) generated and understood images in one model. DeepSeek-VL2 (December) was a vision model built on experts. On 20 November a web-only preview called R1-Lite-Preview showed DeepSeek's first long-reasoning model; its weights were never released.

Then, on 26 December 2024, came DeepSeek-V3.

2025: reasoning, the MIT switch and sparse attention

On 20 January 2025 DeepSeek released R1 and R1-Zero. Both have V3's architecture: 671B total, 37B active. R1-Zero learned to reason with reinforcement learning alone; R1 added a small amount of supervised data first. Part 4 explains how.

The reasoning training was cheap next to the base model. The later Nature version of the R1 paper gives its cost: 147K H800 GPU hours, or about $294K at $2 per GPU hour. That is on top of V3's base training, not instead of it.

R1 came with six small distilled models: smaller open models fine-tuned on answers that R1 wrote.

The rest of 2025 moved fast. V3-0324 (March) improved V3 and moved the V3 line to the MIT license. Prover-V2 (April) proved maths theorems in the Lean language. R1-0528 (May) improved R1, with a distilled Qwen3-8B student. V3.1 (August) joined chat and reasoning into one model with a "thinking" switch. V3.1-Terminus (September) was a polish of it.

On 29 September, V3.2-Exp added DeepSeek Sparse Attention: each token reads only the 2,048 most useful earlier tokens, not all of them. The final V3.2 and V3.2-Speciale followed on 1 December. Between them came DeepSeek-OCR (October), which reads documents from images, and DeepSeekMath-V2 (November), which checks its own proofs. Part 5 covers the sparse attention.

2026: V4, V4.1 and a million tokens

January 2026 brought two research releases: Engram, a memory module that looks up short word sequences in a large table, and DeepSeek-OCR 2. Then on 24 April, DeepSeek released a preview of V4.

The April models were a preview. V4-Flash-0731 and V4-Pro-0813 replaced them as the official versions in July and August. Both carry a new speculative decoding module called DSpark, which guesses several tokens at once and checks them in one step. V4-Flash-Vision-Exp (August) was the first V4 model that sees images.

On 10 September 2026 came V4.1-Flash, the newest main model at the time of writing.

The minor update V4.1-Flash-1017 came on 17 October 2026. Two things have not appeared as of 10 November 2026. DeepSeek's own news page refers to a coming "V4.1-Pro", but no weights exist. Press reports about a vision model called "Thinking with Visual Primitives" cite a GitHub repository that now returns "not found"; this series treats it as unconfirmed.

The catalog in one table

Here is the main line, plus the most useful small models, in one table. Sizes come from the papers and model cards; contexts are the lengths the cards state. The license is the license of the weights.

DateModelTotal / activeContextWeight license
Nov 2023DeepSeek-Coder 1.3B to 33Bdense16KDeepSeek License
Nov 2023DeepSeek LLM 7B, 67Bdense4KDeepSeek License
Jan 2024DeepSeekMoE 16B16.4B / 2.8B4KDeepSeek License
Feb 2024DeepSeekMath 7Bdense4KDeepSeek License
May 2024DeepSeek-V2236B / 21B128KDeepSeek License
May 2024DeepSeek-V2-Lite15.7B / 2.4B32KDeepSeek License
Jun 2024DeepSeek-Coder-V2 (and Lite)236B / 21B (16B / 2.4B)128KDeepSeek License
Sep 2024DeepSeek-V2.5 (and -1210)236B / 21B128KDeepSeek License
Dec 2024DeepSeek-V3671B / 37B128KDeepSeek License
Jan 2025DeepSeek-R1, R1-Zero671B / 37B128KMIT
Jan 2025R1-Distill (Qwen 1.5B to 32B, Llama 8B, 70B)denseas base modelMIT plus the base model's license
Mar 2025DeepSeek-V3-0324671B / 37B128KMIT
Apr 2025DeepSeek-Prover-V2 7B, 671Bdense; 671B / 37B32K; 128Kunclear (MIT file, card cites DeepSeek License)
May 2025DeepSeek-R1-0528 (and Qwen3-8B distill)671B / 37B128KMIT
Aug 2025DeepSeek-V3.1 (Sep: Terminus)671B / 37B128KMIT
Sep 2025DeepSeek-V3.2-Exp671B / 37B128KMIT
Nov 2025DeepSeekMath-V2671B class160K (config)Apache-2.0
Dec 2025DeepSeek-V3.2, V3.2-Speciale671B / 37B128KMIT
Apr 2026DeepSeek-V4-Flash, V4-Pro (preview, with Base models)284B / 13B; 1.6T / 49B1MMIT
Jul, Aug 2026DeepSeek-V4-Flash-0731, V4-Pro-0813284B / 13B; 1.6T / 49B1MMIT
Sep 2026DeepSeek-V4.1-Flash (Oct: -1017)552B + 196B Engram / 8B prefill, 16B decode1MMIT

The same table, read from the real config files

Every model on Hugging Face ships a small text file, config.json, that describes its shape: the number of layers, the width, the number of experts. These files are a few kilobytes each, so anyone can download them without the weights. Our script part1_configs.py downloads 14 of them and counts the parameters from the config fields alone, with no published number as input.

The core of the count for the V2 and V3 families is a direct copy of the two formulas above:

python
def count(c):
    d, L, V = c['hidden_size'], c['num_hidden_layers'], c['vocab_size']
    emb = V * d * (1 if c.get('tie_word_embeddings') else 2)      # input embedding + output head
    attn, norms = attention(c), 2 * d                              # MLA or standard attention, per layer
    ...
    expert = 3 * d * c['moe_intermediate_size']                    # one SwiGLU expert: 3 matrices
    E, S, k = c['n_routed_experts'], c['n_shared_experts'], c['num_experts_per_tok']
    common = emb + L * (attn + norms) + k_dense * dense_ffn + n_moe * router + d
    total = common + n_moe * (E + S) * expert
    active = common + n_moe * (k + S) * expert
    return total, active

And this is its real output, from configs fetched on 10 November 2026 (CPU only, a few seconds):

plain text
model                      date     layers     d      experts ctx(config)  total(count) active(count)   published
-----------------------------------------------------------------------------------------------------------------
deepseek-coder-33b-base    2023-11      62  7168        dense         16K         33.3B         33.3B   33B / dense, 16K
deepseek-llm-67b-base      2023-11      95  8192        dense          4K         67.4B         67.4B   67B / dense, 4K
deepseek-moe-16b-base      2024-01      28  2048   64+2 top-6          4K         16.4B          2.8B   16.4B / 2.8B, 4K
DeepSeek-V2                2024-05      60  5120  160+2 top-6        160K        235.7B         21.4B   236B / 21B, 128K
DeepSeek-V2-Lite           2024-05      27  2048   64+2 top-6        160K         15.7B          2.7B   15.7B / 2.4B, 32K
DeepSeek-Coder-V2-Instruct 2024-06      60  5120  160+2 top-6        160K        235.7B         21.4B   236B / 21B, 128K
DeepSeek-V2.5              2024-09      60  5120  160+2 top-6        160K        235.7B         21.4B   236B / 21B, 128K
DeepSeek-V3                2024-12      61  7168  256+1 top-8        160K        671.0B         37.6B   671B / 37B, 128K
DeepSeek-R1                2025-01      61  7168  256+1 top-8        160K        671.0B         37.6B   671B / 37B, 128K
DeepSeek-V3.1              2025-08      61  7168  256+1 top-8        160K        671.0B         37.6B   671B / 37B, 128K
DeepSeek-V3.2              2025-12      61  7168  256+1 top-8        160K        671.0B         37.6B   671B / 37B, 128K
DeepSeek-V4-Flash          2026-04      43  4096  256+1 top-6          1M      >278.1B*        >7.6B*   284B / 13B, 1M
DeepSeek-V4-Pro            2026-04      61  7168  384+1 top-6          1M       >1.55T*       >28.2B*   1.6T / 49B, 1M
DeepSeek-V4.1-Flash        2026-09      40  5120  384+1 top-6          1M      >545.0B*        >9.9B*   552B + 196B Engram / 8B / 16B, 1M

* V4 and V4.1 rows count the expert weights only (a lower bound); attention, embeddings and the rest are not counted.
  V4.1-Flash: the 9.9B is all 40 layers; DeepSeek says prefill uses 8B because most prompt tokens skip the decoder half.
ctx(config) is max_position_embeddings; the model cards state the context the model was trained and tested for.

DeepSeek-V3 share of weights one token uses: 5.6%  (37.6B of 671.0B)
DeepSeek-V4-Flash experts alone: 278.1B, which is 98% of the published 284B
Config files read: 14, total size 21.4 KB

Read the output column by column. The counted totals match the published totals for every dense, V2 and V3 model, to the first decimal place. So the published sizes are not marketing round numbers; they follow from the shapes in the files.

The active column has one small mismatch: V2-Lite counts 2.7B, while the paper says 2.4B. Our count includes the input embedding and the output head, 0.42B together in V2-Lite. DeepSeek's papers are not consistent on this point, so small differences in active counts are a matter of convention.

Three more lessons hide in the output. First, R1, V3.1 and V3.2 have the same shape as V3; they differ in training, not in size. (V3.2 adds a small 0.85B attention indexer that this count leaves out.)

Second, the max_position_embeddings field is not the context length: V2-Lite's config says 160K, but its paper says 32K. Trust the card. Third, in V4-Flash the experts alone are 98% of all weights, so almost all of a modern DeepSeek model is experts.

1B10B100B1TLLM 67BLLM 67B: total 67.4BLLM 67B: active 67.4B67.4B67.4B (all of it)MoE 16BMoE 16B: total 16.4BMoE 16B: active 2.8B16.4B2.8BV2-LiteV2-Lite: total 15.7BV2-Lite: active 2.4B15.7B2.4BV2V2: total 236.0BV2: active 21.0B236B21BV3 / R1 / V3.xV3 / R1 / V3.x: total 671.0BV3 / R1 / V3.x: active 37.0B671B37BV4-FlashV4-Flash: total 284.0BV4-Flash: active 13.0B284B13BV4.1-FlashV4.1-Flash: total 552.0BV4.1-Flash: active 16.0B552B16BV4-ProV4-Pro: total 1,600.0BV4-Pro: active 49.0B1.6T49Btotal parametersactive per tokenLog scale: each grid line is 10 times the one before.V4.1-Flash: the 552B backbone (its 196B Engram memory is not shown); active is the decode figure.
Total and active parameters of eight DeepSeek models, on a log scale. From V2 on, each token uses only 2% to 9% of the stored weights. The dense 67B model uses all of its weights for every token.

The families: main line and specialists

The catalog has two kinds of models. The main line is the general chat model that DeepSeek serves through its API. The specialists are trained for one job, and most of them start from a main-line model.

202420252026Main lineLLM 67BV2V2.5V3V3.1V3.2V4V4.1ReasoningR1 + distillsR1-0528CodeCoderCoder 1.5Coder-V2Math and proofsMath 7BProverProver-1.5Prover-V2Math-V2Vision and documentsVLJanusVL2Janus-ProOCROCR 2V4-Vision-ExpArchitecture researchMoE 16BESFTNSAmHCEngramDSparkArrows: "built on" or "fed into". Dates are first public release.
DeepSeek models in six lanes. The main line runs along the top; reasoning, code, maths, vision and research models sit below it. Arrows show where one model was built on another, for example Prover-V2 on V3 and Math-V2 on V3.2.

Over time the specialists flow back into the main line. Coder-V2 merged into V2.5, and R1's reasoning merged into V3.1, which has one switch for "thinking" and "non-thinking". Engram, first a research paper, became part of V4.1. Vision moved from separate VL and Janus models into V4.1-Flash itself. So in late 2026 the main line does most jobs, and the specialists remain for narrow tasks such as formal proofs and OCR. Part 8 covers each specialist.

Which model should you look at? It depends on what you want to do.

You want to...Look atWhy
Learn DeepSeek's architectureV3 (paper and reference code), then V2-Lite to run itV3 is the base of most later models; V2-Lite has the same ideas at 16B
Run the newest model yourselfV4.1-Flash-1017 or V4-Pro-0813Both MIT; V4.1-Flash uses 8B to 16B per token, V4-Pro is the largest
Get R1-style reasoning on one GPUR1-Distill-Qwen 7B to 32B, or R1-0528-Qwen3-8BDense, small, fine-tuned on R1's answers
Study reinforcement learning for reasoningR1 and R1-Zero, with the R1 paperThe reference case; Part 4
Study long context and sparse attentionV3.2, then V4Part 5 and Part 6
Prove theorems in LeanProver-V2 (7B or 671B)Trained for formal proofs
Read documents from imagesDeepSeek-OCR 2Small (about 3B), Apache-2.0
Generate and understand imagesJanus-Pro 7BOne model for both directions
Call a model over the internetdeepseek-flash in the APIV4.1-Flash-1017, the cheapest current option

What "open" can mean

"DeepSeek is open source" is a common sentence, and it is partly wrong. To see why, follow a model from raw data to an answer on your screen.

From data to answers: which pieces DeepSeek publishes for its main modelsTraining datadescribed onlyTraining codenot released*Training runGPU hours, in papersWeightsreleasedInference codereleasedAnswersAPI, web, appthe recipe: kept in-housethe result: publishedPapers describe all six steps. Kernels and systems for training and serving are also open (see the infrastructure map).* Narrow exceptions: the Coder fine-tuning script, ESFT, and DeepSpec (training code for draft models).
Six steps from training data to answers. DeepSeek publishes the last three for its main models: the weights, the code to run them, and the answers through its API. The first three, the data, the training code and the training run itself, stay in-house; papers describe them.

An analogy helps. A compiled program is a file that runs, but you cannot easily read or rebuild it. Its source code is what programmers edit, and anyone with the source can rebuild the program. Model weights are like the compiled program. The training data and training code are like the source.

There is a twist. With ordinary software, a program cannot be changed much without its source. With a model, you can change the weights directly: fine-tune them, prune them, quantize them or distill them. So weights alone give you far more freedom than a compiled program does. That is why open weights are so useful, even without the full recipe.

With these definitions, the question "is DeepSeek open?" becomes six smaller questions. The matrix answers them for the main line.

PaperWeightsLicenseInference codeTraining codeTraining dataLLM 67B (2023)DeepSeekCoder (2023)DeepSeekV2 / V2.5 (2024)DeepSeekV3 (Dec 2024)DeepSeekR1 (Jan 2025)MITV3-0324, V3.1MITV3.2 (Dec 2025)MITV4 (Apr 2026)MITV4.1-Flash (Sep 2026)MITreleasedpartial (see the table)not releasedPaper partial: V3.1 and V3-0324 have model cards and change logs, but no new paper.
What DeepSeek released for nine main-line models. Papers and weights are always there; inference code is there from V2 on; training code and training data are never released, except narrow pieces for Coder and V4. The license changed from the DeepSeek License to MIT with R1.

The sections below take the columns one at a time.

Weights and their licenses

Every DeepSeek main model has downloadable weights on Hugging Face, usually as both a Base model and a chat model. V3 and later models ship their main weights in FP8, an 8-bit number format, while V4 stores its experts in 4-bit FP4. Part 7 shows what that means for memory.

The license changed over time.

202420252026DeepSeek License v1.0commercial use allowed, use list in Attachment AR1: MIT"including ... distillation"V3-0324: MITthe V3 line followsMath-V2: Apache-2.0then OCR 2, Engram code, DeepInferV4: MITbase models tooWeight licenses: the dates when each kind first appeared on a DeepSeek model
When each kind of weight license first appeared on a DeepSeek model: the DeepSeek License from October 2023, MIT from R1 in January 2025 and for the V3 line from V3-0324, Apache-2.0 for some specialised models from late 2025, and MIT for all of V4.

The DeepSeek License (2023 to early 2025)

The DeepSeek License Agreement, Version 1.0, is dated 23 October 2023. It covered all models up to and including the first V3. It allows commercial use. But its Attachment A lists forbidden uses, starting with "For military use in any way" and use to harm minors. It also forbids false information that harms others, discrimination, and fully automated decisions that harm people's legal rights.

Two clauses matter more than they look. First, you must pass the same restrictions on to all of your own users. Second, the license defines "Derivatives of the Model" to include "distillation methods" and models trained on "synthetic data by the Model". So under this license, a small model trained on DeepSeek-V3's answers also carries V3's restrictions. The governing law is the law of the People's Republic of China, with courts in Hangzhou.

MIT (from R1, January 2025)

R1 changed this. Its model card says: "This code repository and the model weights are licensed under the MIT License." It adds that the R1 series supports "commercial use, allow for any modifications and derivative works, including, but not limited to, distillation for training other LLMs."

Compare that with the DeepSeek License. The old license treated distillation as a derivative that kept all the restrictions. The new one names distillation as explicitly allowed. That one change made R1 the default teacher for many small reasoning models in 2025.

The V3 line followed two months later. DeepSeek's release note for V3-0324 says: "Models are now released under the MIT License, just like DeepSeek-R1!" Every main model since then, V3.1, V3.2, V4 and V4.1, uses MIT, including the V4 Base models.

Apache-2.0 (late 2025 on)

A third license appeared in November 2025. DeepSeekMath-V2, DeepSeek-OCR 2, the Engram code and the DeepInfer engine use Apache-2.0. It is as permissive as MIT, and it adds an explicit patent grant: contributors promise not to sue users over patents in the code. For a user, MIT and Apache-2.0 give the same practical freedom.

Inference code: how to run the weights

Weights are only numbers. To get answers you need code that knows the model's shape. It must wire the layers, apply attention and route tokens to experts.

DeepSeek's practice here improved over time. For DeepSeek LLM 67B, no special code was needed: it has LLaMA's layout, and Hugging Face Transformers already ran it. For DeepSeekMoE and V2, DeepSeek shipped a modeling_deepseek.py file inside the Hugging Face repository.

For V3, DeepSeek published a short reference implementation in PyTorch, in the inference/ folder of the GitHub repository. It has the model (model.py), a text generator, the FP8 kernels and a tool to convert FP8 weights to 16-bit. R1 uses the same code, because it has the same architecture. V3.2, V4 and V4.1 ship their own inference/ folders inside the Hugging Face repositories.

V4 and V4.1 add an encoding/ folder. Most models describe their chat format as a small template file. DeepSeek instead ships Python code (and later the deepseek-recipe library in Rust and Python) that turns a conversation into tokens. If you write your own serving code, use this encoder; a home-made template can silently break tool calls or thinking mode.

Reference code is written to be read, not to be fast. In practice people run DeepSeek models with open engines such as vLLM, SGLang and llama.cpp, which add DeepSeek support, often on release day. The V4 paper explains why the reference code exists.

Training code: what is missing

This is the column where the answer is almost always "no", so it needs to be exact.

DeepSeek has never released the code that pre-trains its main models, nor the reinforcement learning code that turned V3 into R1. The repositories for LLM, V2, V3, R1, V3.2, the vision models, Math and Prover hold usage examples, inference code, evaluation scripts and papers. None holds a training program for the model itself.

There are three narrow exceptions, and none of them trains a main model:

  1. DeepSeek-Coder ships a fine-tuning script (finetune_deepseekcoder.py). It adapts a finished Coder model to your own data; it does not pre-train.
  2. ESFT (2024) ships full training code for its method, which fine-tunes only the experts that matter for a task, plus small task datasets.
  3. DeepSpec (2026) ships training and evaluation code for the small draft models used in speculative decoding, such as DSpark. It does not train V4 itself.

Training data: described, never shipped

The data is the most closed part. DeepSeek describes its data in its papers: the size, the languages, the share of code and maths, the filtering steps. It has never released a pre-training corpus.

ModelPre-training tokens (as stated in the paper or card)
DeepSeek LLM 67B2T, mainly English and Chinese
DeepSeek-Coder2T, 87% code
DeepSeek-V28.1T
DeepSeek-V314.8T
DeepSeek-V3.1V3 plus 840B tokens of long-context training
DeepSeek-V4more than 32T
DeepSeek-V4.1-Flash45T, text and images

The released datasets are small and special-purpose. They include a synthetic Lean proof dataset for Prover-V1, the ProverBench evaluation set, and the problems and code from V3.2's maths and programming competition runs. These help you test a model, not train one.

There are also good reasons for the gap, and the R1 paper shows one of them.

Papers: the most open part

If the data is the most closed part, the papers are the most open. DeepSeek has published more than 30 technical papers since 2023, most of them on arXiv and free to read. Some, such as Fire-Flyer, the R1 paper (in Nature, September 2025) and the hardware lessons of V3 (ISCA 2025), went through peer review.

The papers are unusually detailed for a commercial lab. The V3 report gives the full training cost breakdown, the FP8 recipe and its failure modes. The V4 and V4.1 papers give layer-by-layer plans that match the config.json files exactly.

A few releases have no paper of their own. V3-0324 and V3.1 have only model cards and release notes. The V3.2-Exp report was published as a PDF in the GitHub repository, not on arXiv. The V4 report first lived on Hugging Face and later moved to arXiv.

The V3 paper ends with a line that explains why DeepSeek publishes so much.

The open infrastructure

The most surprising part of DeepSeek's openness is not a model at all. It is the low-level software that makes training and serving fast.

In the last week of February 2025, DeepSeek held an Open Source Week: "we'll open-source 5 repos, one daily drop". It released, among others:

DayRepositoryWhat it does
1FlashMLAFast MLA attention kernel for decoding on Hopper GPUs
2DeepEPSends tokens between GPUs for expert parallelism
3DeepGEMMFast FP8 matrix multiplication for dense and MoE layers
4DualPipe, EPLB, profile-dataV3's pipeline schedule, its expert load balancer, and real profiling traces
53FS, smallpondThe Fire-Flyer file system and a data processing tool on top of it
6A design noteHow DeepSeek serves V3 and R1 in production

These are parts of the real systems behind V3 and R1, not demos. DualPipe and EPLB are training pieces too: they are part of how DeepSeek trained V3. The full training program still stays closed.

Open infrastructure repos, from the disk up to the serverServingDeepInferOct 2026DeepSpecJun 2026deepseek-recipeSep 2026Parallelism and balanceDualPipeFeb 2025EPLBFeb 2025LPLBNov 2025CommunicationDeepEPFeb 2025DeepEP-AscendSep 2026GPU kernelsFlashMLAFeb 2025DeepGEMMFeb 2025TileKernelsApr 2026DeepSelectSep 2026DeepGEMM-AscendSep 2026Storage and data3FSFeb 2025smallpondFeb 2025Open Source Week, Feb 2025later releasesports to Huawei Ascend
DeepSeek's open infrastructure in five layers. Open Source Week in February 2025 released the storage, kernel, communication and balancing pieces. Later releases added serving (DeepInfer, DeepSpec), more kernels (TileKernels, DeepSelect) and ports to Huawei Ascend chips.

The newer releases fill the gaps. TileKernels (April 2026) holds kernels for MoE routing, FP8 and FP4 quantization, Engram and mHC, V4's wider residual stream (Part 6). Its README says "All kernels have been used in our internal training and inference". DeepSpec (June 2026) trains the draft models for speculative decoding. DeepSelect (September 2026) holds the top-k selection kernels for sparse attention. DeepGEMM-Ascend and DeepEP-Ascend (September 2026) port the main libraries to Huawei's Ascend 950 chips, a sign that DeepSeek now runs on Chinese hardware too.

The inference engine: a reversal

One release shows how DeepSeek's position moved. In April 2025 it published a note called "The Path to Open-Sourcing the DeepSeek Inference Engine". It said its engine was "based on an early fork of vLLM from over a year ago", heavily changed and tied to internal tools. So DeepSeek decided not to release it. It chose instead to give features to the open engines vLLM and SGLang.

Eighteen months later, on 16 October 2026, DeepSeek released DeepInfer under Apache-2.0. Its README calls it "the high-performance inference framework that powers DeepSeek's large-scale production services". The release has limits. It supports one model, V4.1-Flash, on NVIDIA SM100 (Blackwell) GPUs and Ascend 950 chips, for offline inference only.

It leaves out "A KV cache system", the split between prefill and decode machines, and load balancing across replicas. So you get the engine that runs one machine, not the whole service.

Open weights or open source? A scorecard

Now apply the OSI definition to DeepSeek's newest main model, V4.1-Flash, one requirement at a time.

OSI requirementWhat DeepSeek providesOur reading
Parameters under open termsFull weights, MITYes
Code to run the systemReference inference code, encoder, DeepInfer, kernelsYes
Code to train the systemNot released; some kernels and balancers areNo
Code to process and filter dataNot releasedNo
Data information detailed enough to rebuildToken counts and methods in the paperNo

So DeepSeek's main models are open-weight models with open inference and an open low-level stack. They are not open source AI by the OSI definition.

The API: what DeepSeek serves, and at what price

DeepSeek also sells access to its models through an API, a web service that programs can call. The API follows the OpenAI request format at https://api.deepseek.com. Since V3.1 (August 2025) it also accepts the Anthropic request format at https://api.deepseek.com/anthropic.

Which model is behind each name

The model names in the API do not always match the model names on Hugging Face, and they changed often.

FromNameModel behind it
May 2024deepseek-chat, deepseek-coderV2, then V2-0628 and Coder-V2
Sep 2024deepseek-chatV2.5, then V2.5-1210
Dec 2024deepseek-chatV3, then V3-0324 (March 2025)
Jan 2025deepseek-reasonerR1, then R1-0528 (May 2025)
Aug 2025deepseek-chat and deepseek-reasonerV3.1 without and with thinking, then Terminus, V3.2-Exp and V3.2
Apr 2026deepseek-v4-flash, deepseek-v4-proV4 preview; the old names route to V4-Flash and retire on 24 July 2026
Jul, Aug 2026sameV4-Flash-0731, V4-Pro-0813
Sep 2026deepseek-flashV4.1-Flash; V4-Flash names route here
Oct 2026 (now)deepseek-flash, deepseek-v4-proV4.1-Flash-1017 and V4-Pro-0813

In September 2026 DeepSeek first said that V4-Pro requests would move to V4.1-Flash. It then changed its mind: "we have decided to continue providing API services for DeepSeek V4 Pro after September 14, 2026". So two models are served today.

Prices over time

All prices below are in US dollars per one million tokens. They come from DeepSeek's pricing page and its archived copies.

$0$1$2$3$420252026V3 list priceV3.2-ExpV4-FlashV4.1-FlashV4-Pro listR1default model, outputdefault model, input (cache miss)reasoner, then V4-Pro, outputDashed: no archivedprice page found.From Aug 2026: peakprices; off-peak is half.US dollars per 1 million tokens, DeepSeek API
DeepSeek API prices per million tokens from November 2024 to November 2026. The default model's output price rose with V3 and V3.1, fell to $0.42 with V3.2-Exp and to $0.28 with V4-Flash, and is $1.20 at peak for V4.1-Flash. The premium line is R1, then V4-Pro.
FromModelInput, cache hitInput, cache missOutput
Nov 2024 (earliest capture)V2.5$0.014$0.14$0.28
26 Dec 2024 to 8 Feb 2025V3, at V2's prices$0.014$0.14$0.28
8 Feb 2025V3$0.07$0.27$1.10
20 Jan 2025R1$0.14$0.55$2.19
5 Sep 2025V3.1, one price for both modes$0.07$0.56$1.68
29 Sep 2025V3.2-Exp (and V3.2 from December)$0.028$0.28$0.42
24 Apr 2026V4-Flash$0.028$0.14$0.28
24 Apr 2026V4-Pro, list price (75% off at launch)$0.145$1.74$3.48
16 Aug 2026, peakV4-Flash-0731$0.014$0.44$1.32
16 Aug 2026, peakV4-Pro-0813$0.044$1.32$3.96
10 Sep 2026, peak (now)V4.1-Flash (deepseek-flash)$0.006$0.30$1.20

Two rules complete the picture. From 26 April 2026, every cache-hit price was cut to one tenth; the table shows the later prices. From 16 August 2026, prices have a peak and an off-peak level: "Off-peak rates are half of the peak rates". Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays. An earlier off-peak discount (16:30 to 00:30 UTC) ran in 2025 and ended on 5 September 2025.

A worked example shows what these prices mean.

Say an app sends 10,000 requests a day to deepseek-flash at peak. Each request has 2,000 input tokens, of which 1,500 are a cached system prompt, and 500 output tokens. Per day that is 15M cache-hit tokens, 5M cache-miss tokens and 5M output tokens. The bill is 15×0.006+5×0.30+5×1.20=0.09+1.50+6.00=$7.5915 \times 0.006 + 5 \times 0.30 + 5 \times 1.20 = 0.09 + 1.50 + 6.00 = \$7.59 per day. At off-peak hours it would be half, $3.80. Output dominates the bill, and the cached prompt costs almost nothing.

What you can download, run and rebuild

Here is the whole part as one checklist.

You can download the weights of every main DeepSeek model, from LLM 67B to V4.1-Flash-1017, plus most specialists. Since R1 (and since V3-0324 for the V3 line), almost all of them are MIT, so commercial use, fine-tuning and distillation are allowed. Read the license file of older models and of the few with mixed labels.

You can run them with DeepSeek's reference code, with DeepInfer (V4.1-Flash only), or with open engines such as vLLM, SGLang and llama.cpp. The big ones need many GPUs; Part 7 does the memory arithmetic.

You can read how they were built in more than 30 papers. You can also reuse the kernels, communication libraries, schedulers and file system that DeepSeek trains and serves with.

You cannot download the pre-training data, the data filters, the HAI-LLM training framework, or the reinforcement learning code behind R1. So you cannot reproduce any DeepSeek main model exactly. Anything you train from the papers is a new model, not a copy.

Next: Part 2, the V3 architecture opens the model that most of this catalog is built on. It covers many small experts, latent attention and load balancing without an extra loss. It also counts exactly where V3's 671 billion parameters live.

References

  1. DeepSeek-AI. DeepSeek LLM: Scaling Open-Source Language Models with Longtermism. 2024.
  2. DeepSeek-AI. DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model. 2024.
  3. DeepSeek-AI. Fire-Flyer AI-HPC: A Cost-Effective Software-Hardware Co-Design for Deep Learning. SC24, 2024.
  4. DeepSeek-AI. DeepSeek-V3 Technical Report. 2024.
  5. DeepSeek-AI. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. 2025. Nature version: DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning, Nature 645, 2025.
  6. DeepSeek-AI. DeepSeek-V3.2: Pushing the Frontier of Open Large Language Models. 2025.
  7. DeepSeek-AI. DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence. 2026.
  8. DeepSeek-AI. DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression. 2026.
  9. Model weights and cards: deepseek-ai on Hugging Face; code: deepseek-ai on GitHub; the DeepSeek License Agreement; the R1 model card.
  10. Infrastructure: open-infra-index (Open Source Week and the inference engine note), DeepInfer, TileKernels, DeepSpec.
  11. API: change log, pricing, V3-0324 release note, V4.1-Flash release note.
  12. Open Source Initiative. The Open Source AI Definition 1.0. 2024.
  13. SemiAnalysis. DeepSeek Debates. 2025 (third-party estimate, cited only as such).