Why did 2026 become the year text diffusion shipped?
On 19 October 2026, Inception released Mercury 3, a language model that does not write left to right. It starts from a blank answer and fills it in over a few passes, many words at a time, the way an image diffusion model sharpens noise into a picture.
Inception says Mercury 3 has more than 40 times the parameters of Mercury 1, runs at 1,068 tokens a second on NVIDIA GPUs, and beats GPT-6 Luna and Claude Haiku 5.5 across a range of benchmarks. Those are the company’s own claims, from a blog post; there is no paper.
The size is the striking part. Mercury Coder Mini already ran at 1,109 tokens a second on an H100 in 2025, as measured by Artificial Analysis: the speed held while the model grew.
Mercury 3 closed a year of releases. Google DeepMind put out DiffusionGemma as open weights: a Gemma 4 mixture-of-experts model retrained to write in parallel, averaging about 20 tokens per forward pass and roughly 1,500 tokens a second on one H100. NVIDIA released two diffusion families, Nemotron-Labs-Diffusion and TwoTower; the TwoTower announcement drew 4,755 likes on X.
Ant Group’s LLaDA line, at 100 billion parameters since December 2025, learned to edit its own tokens (LLaDA2.1 in February, LLaDA2.2 in July). Zyphra converted an 8B model on AMD GPUs. ByteDance Seed and Tohoku University showed that training from scratch still works, on 12 trillion and 1.5 trillion tokens.
Two years earlier this was an open problem. In 2024 the best text diffusion models were the size of GPT-2, and the news was that they had come close to autoregressive models on perplexity at all. None of them was a product.
Diffusion language models are what my research is about these days, and this series is the map of 2026 I wanted for myself. It is built from about 70 papers that drew attention on X between January and October, and it follows one question. A diffusion language model writes many tokens per forward pass instead of one: what does that buy, what does it break, and what did 2026 do about each break?
This part builds the machine from scratch: how the canvas works, why it is fast, why everyone writes in blocks, and who shipped what. Start with a puzzle.
The 30-second version
Because extra positions in a pass are cheap only while the GPU is waiting for memory. For one user, every pass spends its time reading the model's weights, so working on 20 positions instead of 1 adds little, and that user sees the speed-up. Even then it is not free: DiffusionGemma's pass takes 3.2 times as long as an AR step, and its measured speed-up for one user is about 7 times, not 20. On a busy server the autoregressive model fills the same pass with other users' tokens, the spare capacity is gone, and DiffusionGemma's own report has AR models winning on throughput from about 32 concurrent requests. Part 8 works through the numbers.How does a diffusion model write an answer?
Start with the model everyone knows. An autoregressive (AR) model, the kind behind most chatbots, writes one tokenTokenThe unit a language model reads and writes: a word, a piece of a word or a punctuation mark, chosen from a fixed vocabulary of tens or hundreds of thousands of entries. per forward passForward passOne run of the network from its input to its output: every layer applied once, every weight used once. Generating text is a loop of forward passes.. It reads everything written so far, predicts the next token, appends it, and runs again. A six-token answer takes six passes, always.
A diffusion model writes on a canvas instead. Ask it: Name a US city and its most famous bridge. It lays out a fixed number of empty slots for the answer, say six, each holding a mask token, written [M] here. Then it runs forward passes over the whole canvas, and each pass fills in some of the slots.
To make the passes easy to follow, give the model two answers it has learned equally often, six tokens each: San Francisco: the Golden Gate and New York: the Brooklyn Bridge. Treat each word and the colon as one token. This canvas comes back in every part of the series.
Pass 1 reads the prompt and the six masks and predicts a word for every masked slot at once. Each prediction is the slot’s marginalMarginalThe probability of each word for one slot taken on its own, averaged over whatever the other slots turn out to be. Its opposite is the joint: the probability of a whole combination of words at once.: its guess on its own, without knowing what the other slots will become. Slot 1 is San or New, 0.5 each. Slot 3 is the colon with probability 1, slot 4 is the with probability 1, and the other slots are coin flips like slot 1.
A confidence rule decides what gets written. A simple one writes a slot when its top word reaches 0.9. After pass 1 that is the colon and the: two tokens from one pass. The other four slots stay masked, and the next pass predicts them again.
Pass 2 finds nothing sure. The colon and the belong to both answers, so writing them settled nothing. When no slot clears the bar, the rule writes the single most confident slot anyway, drawing its word from the prediction. Say slot 1 comes up San.
That one coin flip settles three other slots. Pass 3 reads a canvas that already says San, and only one learned answer starts that way, so Francisco, Golden and Gate each come out at probability 1. All three clear the bar and are written together.
Six tokens in three passes is 2 tokens per forward2 tokens per forward, worked outpass 1 writes 2 (the colon, the), pass 2 writes 1 (San), pass 3 writes 36 tokens ÷ 3 passes = 2An AR model is 1 by definition., against the AR model’s one. Tokens per forward, the number of tokens committed per forward pass, is the series’ unit of parallelism. A greedier rule that writes the sure slots and one coin flip in the same pass finishes in 2 passes, 3 tokens per forward.
Why not be greedier still and write all four uncertain slots in pass 2? Because each would be drawn from its own 50/50, independently of the others. That makes 16 equally likely outcomes16 outcomes, worked out4 slots, 2 words each, drawn independently2 × 2 × 2 × 2 = 2⁴ = 16, and only 2 are real answers: 12.5%12.5%, worked outreal answers: San Francisco, Golden Gate and New York, Brooklyn Bridge2 ÷ 16 = 0.125The other 87.5% mix the two answers. come out consistent, and the rest are mixtures like New Francisco: the Golden Bridge. That mixing is the price of parallel writing, and Part 3 is about it.
Real models run the same loop over hundreds of slots and vocabularies of 100,000 tokens and more, with their own rules for what to write. TwoTower writes a token once its probability passes 0.8. LLaDA2.2-flash’s model card evaluates with a threshold of 0.5. DiffusionGemma accepts tokens from the least to the most uncertain until an entropy budget is spent, and stops early once its predictions stop changing.
Not every model starts from masks, either. DiffusionGemma and Sumi start the canvas as random tokens and let any token change at any pass, which is called uniform noise. The loop is the same; what an undecided slot looks like is different, and Part 5 asks which is better.
How do you train a model to fill in a canvas?
By breaking real text and asking for it back. Take a sentence from the training data, pick a noise level t between 0 and 1, and replace each token with [M] independently with probability t. At t = 0.1 about a tenth of the sentence is hidden; at t = 1 all of it is. The model sees the damaged sentence and predicts the original token at every masked position.
The loss is the familiar cross-entropy, counted only at the masked positions. Written out, as in MDLM and LLaDA:
\[\mathcal{L}(\theta) = -\,\mathbb{E}_{t,\,x_0,\,x_t}\left[\frac{1}{t}\sum_{i=1}^{L}\mathbf{1}\left[x_t^i = \mathrm{M}\right]\log p_\theta\left(x_0^i \mid x_t\right)\right]\]In words: x₀ is the clean sentence of L tokens and xₜ the damaged one. At every masked position i, take the model’s surprise at the true token, add them up, and divide by t. The division evens out the noise levels: at t = 0.1 only about a tenth of the positions are masked, so the sum has a tenth as many terms, and dividing by 0.1 puts it back on the scale of a fully masked sentence.
Why “diffusion”? Training corrupts text step by step until nothing is left, and the model learns to undo each step. Generation runs the noise level backwards, from all masks to none, which is exactly the pass-by-pass loop on the canvas. The weighted loss is also an upper bound on the model’s negative log-likelihood, a fact Part 7 leans on when it brings in reinforcement learning.
The network itself is a transformer, almost unchanged. The one difference from an AR model is the attention mask. An AR model uses a causal mask, so each position sees only the positions before it. A diffusion model needs every slot to see every other slot, before and after, so its attention is bidirectional.
Swap the mask, change the loss, and an AR model can be retrained into a diffusion model. That is how most of 2026’s models were built, and Part 2 is about what the conversion keeps and what it breaks.
Why is one forward pass nearly free for one user?
Because the GPU spends a pass waiting for weights, not doing arithmetic. Take an 8-billion-parameter model stored in bf16bf16A 16-bit floating-point format, 2 bytes per number, with the same exponent range as 32-bit floats and less precision. The usual format for serving model weights.: 16 GB16 GB, worked out8 × 10⁹ parameters × 2 bytes each= 16 × 10⁹ bytes = 16 GBRule of thumb: 2 GB per billion parameters in bf16. of weights. They live in the GPU’s high-bandwidth memory, and a forward pass has to bring every one of them to the compute units.
An H100 reads its memory at 3.35 TB/s, so one pass takes at least 4.8 ms4.8 ms, worked out16 GB ÷ 3,350 GB/s= 0.00478 s ≈ 4.8 ms just to read the weights. For one user writing one token per pass, that caps the speed at about 209 tokens a second209 tokens a second, worked outpasses per second: 1 ÷ 0.00478 s ≈ 209.41 token per pass × 209.4 ≈ 209 tokens a second, however fast the arithmetic is.
The arithmetic is fast. One position costs about 2 floating-point operations per parameter, a multiply and an add, so 16 GFLOP16 GFLOP, worked out2 FLOPs × 8 × 10⁹ parameters= 16 × 10⁹ FLOPs per position for this model. At the H100’s 989 TFLOP/s of dense bf16 that is 0.016 ms0.016 ms, worked out16 × 10⁹ ÷ 989 × 10¹² FLOP/s≈ 1.6 × 10⁻⁵ s = 0.016 msAbout a three-hundredth of the 4.8-ms read., a tiny fraction of the time the read takes.
Now let the same pass work on 20 positions instead of one. The weights are still read once, in 4.8 ms, and every position uses them while they are on chip. The arithmetic grows twentyfold, to 0.32 ms, and still hides under the read.
The arithmetic catches up with the read only at about 295 positions295 positions, worked outa pass reads 2 bytes per parameter and does 2 FLOPs per parameter per positionso n positions do n FLOPs for every byte readthe H100 does 989 × 10¹² ÷ 3.35 × 10¹² ≈ 295 FLOPs per byteThe H100’s ridge point: below about 295 positions a pass is memory-bound. in one pass. Below that the pass is memory-bound: its time is set by the bytes it moves, not the work it does. A diffusion model that writes 20 tokens per pass is spending arithmetic that the AR model leaves idle.
So for one user, tokens per forward sets the speed directly. Every pass costs 4.8 ms whatever it writes: 2 tokens per pass is 419 tokens a second, 6 is 1,256, and 20 is about 4,1884,188 tokens a second, worked out209.4 passes a second for one user20 tokens per pass × 209.4 ≈ 4,188 tokens a second.
This is the whole pitch of text diffusion, and it is honest arithmetic. It is also a toy: a real pass also pays for attention, for reading the stored keys and values of earlier tokens, and for the sampler. The next question is how much of the toy survives a real model.
Why isn’t a real model 20 times faster?
DiffusionGemma’s report answers with measurements. Its denoising pass covers a canvas of 256 tokens and takes 13.56 ms on one H100 in FP8, for a single request. The report puts that at 3.2 times a single-token AR step: 256 times the positions for 3.2 times the time.
Most of the extra time comes from the model’s mixture of expertsMixture of experts (MoE)A layer split into many small feed-forward networks, the experts, with a router that sends each token to only a few of them. The model holds many parameters but uses only a fraction for each token.. Gemma 4 sends each token to 8 experts per MoE layer. A canvas of 256 tokens wakes about 84 different experts per layer, about 10 times as manyabout 10 times, worked out84 experts per layer for the canvas ÷ 8 for one token= 10.5, so a pass reads far more expert weights and the MoE kernel runs 4.3 times slower. Attention runs 4 times slower too, and the diffusion sampler takes 3.06 ms against 0.56 ms for AR sampling.
So in a mixture of experts the weight read is not fixed after all: more positions touch more weights. Even so, 19.74 tokens per pass in 13.56 ms is about 1,456 tokens a second1,456 tokens a second, worked outtokens per second = tokens per forward ÷ time per pass19.74 ÷ 0.01356 s ≈ 1,456The report’s own formula; measured directly, it gets 1,479., and the report measures 1,479 directly.
Gemma 4 writing one token at a time manages 204 tokens a second on the same setup, and 303 with its multi-token prediction, a form of speculative decodingSpeculative decodingA cheap drafter guesses several next tokens, and the full model checks all of them in one forward pass, keeping the longest prefix it agrees with. The output follows the full model’s own distribution exactly, only faster.. DiffusionGemma is 7.1 times7.1 times, worked outagainst plain AR: 1,456 ÷ 204 ≈ 7.1against AR with multi-token prediction: 1,456 ÷ 303 ≈ 4.8 the first and 4.8 times the second, for one user.
A server is a different machine. It batches many users’ requests into one pass, and an AR pass carrying 32 users computes 32 positions and writes 32 tokens. The arithmetic the diffusion model was getting for free is now spent on other people’s tokens, and the AR model’s old advantage comes back: it commits everything it computes.
DiffusionGemma’s report says AR models begin to win on throughput at around 32 concurrent requests, with the caveat that it did not optimize for batches larger than one. NVIDIA’s Nemotron-Labs-Diffusion keeps an AR mode inside the same weights for this reason, and its paper recommends AR mode when serving with high concurrency.
So text diffusion’s clear win is latency: one user, or a few, waiting for an answer. Peak throughput on a full server is contested ground, and Part 8 works out where the crossover sits with a toy roofline and what the 2026 serving papers do about it.
Why does nearly every shipped model write in blocks?
Because a canvas that covers the whole answer has two problems. Its length is fixed before the first pass. And it cannot reuse work. In an AR model, every finished token’s keys and values, the vectors attention reads from it, never change, so they are stored in a KV cacheKV cacheThe stored keys and values of every token already processed, one pair per layer and head. With it, each new pass computes only the new positions and reads the rest from memory. and each pass computes only the newest token.
With bidirectional attention, every pass can change every slot and every slot sees the prompt, so the keys and values of the whole sequence are recomputed each time. A 1,000-token prompt with a 256-token answer means 1,256 positions per pass: about 20 ms of arithmetic20 ms, worked out1,256 positions × 16 GFLOP ≈ 20.1 TFLOP20.1 × 10¹² ÷ 989 × 10¹² FLOP/s ≈ 20.3 msFour times the 4.8-ms weight read: well past 295 positions, so compute-bound. for the 8B model, four times the weight read. The pass is no longer free.
Block diffusion (Arriola and others, ICLR 2025) splits the difference. The answer is written in blocks of B tokens, left to right. Inside a block the slots are denoised together and see each other. A block also sees everything before it, but nothing after. Once a block is finished its tokens are final, so their keys and values go into the cache, just as an AR model’s would.
With B = 1 this is an AR model. With one block as long as the whole answer it is the full canvas. In between, each pass works on only B positions: a block of 32 costs 0.5 ms of arithmetic0.5 ms, worked out32 positions × 16 GFLOP ≈ 0.51 TFLOP0.51 × 10¹² ÷ 989 × 10¹² FLOP/s ≈ 0.52 ms for the 8B model, well under the 4.8-ms read. And the answer can grow block by block until the model writes an end-of-text token.
Block 2 in the figure shows a second gift of blocks. The year depends on the bridge, so on its own it would be another coin flip. But block 2 reads the finished block 1, where the bridge is already decided, and the whole block is written in one pass: twelve tokens in four passes, 3 tokens per forward3 tokens per forward, worked outblock 1: 6 tokens in 3 passes; block 2: 6 tokens in 1 pass12 tokens ÷ 4 passes = 3.
Nearly every model in this part works this way. DiffusionGemma denoises 256 tokens at a time. LLaDA2.2-flash and Nemotron-Labs-Diffusion’s sampler evaluations use blocks of 32, TwoTower and Zyphra’s ZAYA1 use 16, and FLARE uses 4. Even iLLaDA, trained with fully bidirectional attention, samples in blocks of 16 to 512 tokens depending on the benchmark.
The block size is a real trade. Bigger blocks offer more parallelism, but DreamReasoner-8B found that training with large blocks wrecks long chain-of-thought reasoning while small blocks preserve it. It fixed that with a curriculum, from blocks of 4 up to a mix of 4 to 32. Nemotron-Labs-Diffusion likewise gets its best accuracy from a moderately small block.
Who shipped what in 2026?
Here are the releases of the year that a team could download or call, with each row built only from its paper or its maker’s page.
| model | maker, date | size | how it writes | built | speed, as its source reports it |
|---|---|---|---|---|---|
| Mercury 3 | Inception, Oct 19 | not disclosed; over 40 times Mercury 1 | not disclosed | not disclosed | 1,068 tokens/s on NVIDIA GPUs (Inception's claim) |
| Mercury 2.5 | Inception, Sep | not disclosed | not disclosed | not disclosed | 1,107 tokens/s on NVIDIA GPUs (Inception's claim) |
| DiffusionGemma | Google DeepMind, open weights; report Jul 31 | 25.2B MoE, 3.8B active | uniform noise, blocks of 256 | converted from Gemma 4 | 19.74 tokens per forward; 1,479 tokens/s on one H100, FP8, one request |
| Nemotron-Labs-Diffusion | NVIDIA, paper Jul 7 | 3B, 8B, 14B | blocks from masks; also AR and self-speculation modes | continued from Ministral3 | 8B: 2.57 tokens per forward in diffusion mode, 5.99 to 6.38 in self-speculation; Qwen3-8B: 1 |
| Nemotron-Labs-TwoTower | NVIDIA, Jun 25 | a 30B MoE (3B active), twice: one copy frozen | masked, blocks of 16 | frozen AR tower plus a trained denoiser tower | 2.42 times the AR baseline's throughput at 98.7% of its quality, 2 H100s |
| LLaDA2.1 | Ant Group, Feb 9 | 16B and 100B MoE | masked, plus token-to-token editing | converted from an AR model, as LLaDA2.0 was | 100B: 13.81 tokens per forward and 892 tokens/s (FP8) on HumanEval+ |
| LLaDA2.2-flash | Ant Group, Jul | 100B MoE | blocks of 32; edits that substitute, insert and delete | not stated on its page | 519 tokens/s on SWE-bench Verified, against 303 for Ling-2.6-flash with multi-token prediction |
| ZAYA1-8B-Diffusion-Preview | Zyphra, May 14 | 8B MoE | masked, blocks of 16 | converted from ZAYA1-8B, on AMD GPUs | 4.6 times (lossless sampler) and 7.7 times theoretical speed-up over AR; no wall-clock figure |
The last column is not in one unit, on purpose: each row reports what its source measured. Tokens per forward counts committed tokens and ignores how long a pass takes. Tokens per second depends on the GPU, the precision, the batch and the benchmark. Mercury’s and ZAYA1’s numbers are the makers’ claims from blog posts, with no setup published.
Some rows hide a twist. Nemotron-Labs-Diffusion’s widely quoted “6 times the tokens per forward of Qwen3-8B” is its self-speculation mode, where diffusion drafts and the same model checks the draft causally; pure diffusion mode is 2.57. Its 8B scores 63.18 on its ten-benchmark average in diffusion mode, against 62.75 for Qwen3-8B.
LLaDA2.1’s editing pays off directly in tokens per forward. Its fast “Speedy” mode writes drafts with a low threshold and repairs them afterwards, reaching 13.81 tokens per forward on HumanEval+, 2.1 times2.1 times, worked outLLaDA2.1-flash, Speedy mode: 13.81 tokens per forwardLLaDA2.0-flash: 6.4513.81 ÷ 6.45 ≈ 2.1 LLaDA2.0-flash’s 6.45, at a slightly higher score (89.63 against 88.41).
LLaDA2.2-flash is the first of these aimed at agents: 128K tokens of context, tool use, and SWE-bench runs inside a coding-agent scaffold. It is 1.7 times as fast1.7 times, worked out519.0 ÷ 303.2 tokens a second on SWE-bench Verified≈ 1.71 as Ant’s own AR model on SWE-bench Verified, but scores 49.28 there against the AR model’s 61.20. The speed is real; the quality gap on long agent tasks is too.
Ant also put the LLaDA2.0-mini backbone, 16B in total, behind images: LLaDA2.0-Uni reads and generates pictures with the same block masked-diffusion model, turning images into discrete tokens on the way in and decoding them with a separate diffusion decoder on the way out.
Should you convert an autoregressive model or train one from scratch?
Converting is the cheap route, and it won 2026. Take a trained AR model, replace its causal attention with bidirectional attention inside each block, and keep training it on the denoising loss. The model keeps most of what it knew about language and only has to learn a new way to write.
| model | starts from | training tokens | against its AR source or peers |
|---|---|---|---|
| DiffusionGemma | Gemma 4, 25.2B MoE | under 10% of Gemma 4's budget | trades some benchmark score for speed; no single figure given |
| Nemotron-Labs-TwoTower | Nemotron-3-Nano-30B-A3B | about 2.1T, against 25T for the backbone | 98.7% of the AR baseline's quality |
| Nemotron-Labs-Diffusion | Ministral3 base | 1T more AR, then 300B joint AR and diffusion | 8B, diffusion mode: 63.18 against Qwen3-8B's 62.75 |
| ZAYA1-8B-Diffusion-Preview | ZAYA1-8B base | 600B, then 500B to reach 128K context | no systematic loss with the lossless sampler (Zyphra) |
| DreamReasoner-8B | Qwen3-8B base | 160B | AIME 2024: 73.8 (blocks of 4) against 76.0 for Qwen3-8B |
| FLARE-9B | Qwen3.5-9B | about 10B | MATH-500: 95.20 against 96.60 |
| dQwen3.5 | Qwen3.5, 0.8B to 9B | not stated in the abstract | reaches a given loss in about half the tokens of a full-attention control |
| iLLaDA | nothing: 8B from scratch | 12T | base GSM8K 81.9 against Qwen2.5-7B's 78.9; instruct MATH 56.7 against 75.5 |
| Sumi | nothing: 7B from scratch, uniform noise | 1.5T | MMLU 51.1 against Llama 2-7B's 46.0; HellaSwag 60.0 against 76.2 |
The budgets tell the story. TwoTower’s 2.1 trillion tokens sound large until you set them against the 25 trillion its backbone was pretrained on: 8.4%8.4%, worked out2.1T ÷ 25T = 0.084The same order as DiffusionGemma’s “under 10%”., the same order as DiffusionGemma’s. FLARE gets a 9B model within a point and a half of its source on MATH-500 with about 10 billion tokens, and argues that the quality of the transfer data matters more than the loss or the mask.
TwoTower is the most cautious design of the lot. It never retrains the AR model at all: a frozen copy reads the clean context, and a second copy, initialized from the same checkpoint, learns to denoise the next block by attending to what the frozen copy computed. dQwen3.5 shows that even hybrid models whose recurrent layers are causal by construction can be converted.
Every production model in the first table that discloses its recipe was converted. Training from scratch is now the research reference rather than the product route, and 2026 had two serious ones.
iLLaDA, from ByteDance Seed and Renmin University, is an 8B masked diffusion model trained on 12 trillion tokens and kept on the diffusion objective through fine-tuning. Its base model beats Qwen2.5-7B on GSM8K and MMLU (74.8 against 71.9); its instruction-tuned model still trails on MATH and on HumanEval (65.9 against 84.8).
Sumi, from Tohoku University, is the first fully open 7B model with uniform noise trained from scratch, on 1.5 trillion tokens, with its data mixture and checkpoints released. Against AR models with similar budgets it is competitive on knowledge, reasoning and code and trails on commonsense, which its authors put down to an education-heavy data mix.
Why bother with the expensive route? Because a converted model inherits its parent’s habits. It learned language left to right, and Part 2 shows what that inheritance does to a model that is supposed to write in any order. A model trained from scratch is the clean measurement of what diffusion alone can do.
What are the catches?
Every catch in this series comes from the same place: a model that writes many tokens per pass has to decide them in parallel, and parallel decisions are only as good as the slots’ independence. Each later part takes one catch.
The first is New Francisco. Writing several uncertain slots in one pass draws each from its own marginal, and two correlated slots mix answers. A confidence threshold avoids the mixing by writing less per pass, which gives back the speed. Part 3 is about where that wall sits and the order a model should write in.
The second is finality. Under masking, a written token never changes: the mask is a one-way door. Write San too early and the model is committed to it. LLaDA2.1 adds token-to-token editing, LLaDA2.2 adds insertions and deletions, and uniform-noise models like Sumi can rewrite any token at any pass; Part 4 follows the ways to take a token back.
The third is the noise itself. Masks erase a slot in one event; random tokens replace it with a wrong word; continuous diffusion blurs an embedding vector. DiffusionGemma chose uniform noise and also feeds each pass’s prediction back into the next as a continuous signal, its report’s self-conditioning. Part 5 weighs the options.
The fourth is the computation nobody reads. Every pass predicts every undecided slot, so the bridge slot’s 50/50 is computed in pass 1 and pass 2 before anything is written there. Part 6 asks what that hidden work does, and what it means for reading a model’s reasoning.
The fifth is learning from reward. Reinforcement learning for language models needs the probability of a whole answer, and a diffusion model only offers a bound on it that depends on the order of unmasking. LLaDA2.1 ran the first large-scale RL for these models with a bound-based method; Part 7 covers the year’s routes around the missing likelihood.
The sixth is the server, which the puzzle already met: the speed-up shrinks as the batch grows, and caching a bidirectional model takes care. Part 8 does the serving numbers, the training costs, and the harder question of how to measure these models fairly.
Part 2 comes first, though, because it asks the question this part’s tables raise: if nearly every shipped model is a converted AR model, is the endgame a diffusion model at all, or an AR model with a diffusion head? Part 9 puts the open problems side by side.
Rapid fire: can you do these from memory?
- With a 0.9 confidence rule, how many passes does the two-bridge answer take on a diffusion canvas, and on an AR model? What is each one's tokens per forward?
- Why does writing all four uncertain slots of the canvas in one pass give a consistent answer only 12.5% of the time?
- Write the masked diffusion training loss. What does the division by t do?
- An 8B model in bf16 on one H100: how long does a forward pass take for one user, and why is it about the same for 1 position and 20?
- At about how many positions per pass does the arithmetic catch up with the weight read on an H100, and where does the number come from?
- DiffusionGemma writes about 20 tokens per pass but is about 7 times faster than Gemma 4 for one user, not 20. Give two reasons, and say why the gap shrinks further on a busy server.
- What does block diffusion cache? What are block size 1 and a block as long as the answer?
- Name two 2026 models converted from AR checkpoints and two trained from scratch, with their token budgets.
Where can you go deeper?
- Inception, Introducing Mercury 3 (blog post, 2026), inceptionlabs.ai/blog/introducing-mercury-3, and Introducing Mercury 2.5 (blog post, 2026), inceptionlabs.ai/blog/introducing-mercury-2-5. The release claims: more than 40 times Mercury 1’s parameters, 1,068 and 1,107 tokens a second, and the benchmark comparisons. No method details.
- Inception Labs and others, Mercury: Ultra-Fast Language Models Based on Diffusion (preprint, 2025), arXiv:2506.17298. Mercury Coder Mini and Small at 1,109 and 737 tokens a second on H100s.
- DiffusionGemma Team, Adrien Ali Taïga and others, DiffusionGemma Technical Report (preprint, 2026), arXiv:2608.00146; weights at huggingface.co/google/diffusiongemma-26B-A4B-it. Uniform noise on 256-token canvases, self-conditioning, the entropy-bounded sampler, and the speed analysis this part quotes (13.56 ms per pass, 84 experts against 8, the crossover near 32 concurrent requests).
- Yonggan Fu and others, Nemotron-Labs-Diffusion: A Tri-Mode Language Model Unifying Autoregressive, Diffusion, and Self-Speculation Decoding (preprint, 2026), arXiv:2607.05722. One model, three ways to decode, and the advice to use AR mode at high concurrency.
- Fitsum Reda and others, Nemotron-Labs-TwoTower: Diffusion Language Modeling with Pretrained Autoregressive Context (preprint, 2026), arXiv:2606.26493; code and weights at huggingface.co/collections/nvidia/nemotron-labs-twotower. A frozen AR context tower and a trained denoiser tower.
- Tiwei Bie and others, LLaDA2.1: Speeding Up Text Diffusion via Token Editing (preprint, 2026), arXiv:2602.08676; code at github.com/inclusionAI/LLaDA2.X. Mask-to-token plus token-to-token decoding, the Speedy and Quality modes, and EBPO, the first large-scale RL for these models.
- inclusionAI, LLaDA2.2-flash (model release, 2026), huggingface.co/inclusionAI/LLaDA2.2-flash and github.com/inclusionAI/LLaDA2.X. Levenshtein editing (keep, substitute, delete, insert, with new DELETE and INSERT tokens), 128K context, the agent benchmarks; its technical report is LLaDA2_2_tech_report.pdf in the same repository.
- Tiwei Bie and others, LLaDA2.0: Scaling Up Diffusion Language Models to 100B (preprint, 2025), arXiv:2512.15745. The conversion recipe behind the LLaDA2 line: block size growing, then full-sequence diffusion, then back to small blocks.
- Inclusion AI, Tiwei Bie and others, LLaDA2.0-Uni: Unifying Multimodal Understanding and Generation with Diffusion Large Language Model (preprint, 2026), arXiv:2604.20796; code at github.com/inclusionAI/LLaDA2.0-Uni.
- Zyphra, ZAYA1-8B-Diffusion-Preview (blog post, 2026), zyphra.com/post/zaya1-8b-diffusion-preview. A mixture-of-experts AR model converted to block diffusion, trained on AMD GPUs.
- Shen Nie and others, Improved Large Language Diffusion Models (preprint, 2026), arXiv:2606.25331; code at github.com/ML-GSAI/LLaDA. iLLaDA: 8B from scratch on 12T tokens.
- Mengyu Ye and others, Sumi: Open Uniform Diffusion Language Model from Scratch (preprint, 2026), arXiv:2606.19005; project page at nlp.ecei.tohoku.ac.jp/projects/sumi, code at github.com/tohoku-nlp/sumi.
- Zirui Wu and others, DreamReasoner-8B: Block-Size Curriculum Learning for Diffusion Reasoning Models (preprint, 2026), arXiv:2606.19257; code at github.com/DreamLM/DreamReasoner.
- Anton Xue and others, dQwen3.5: Hybrid-Attention Diffusion Language Models (preprint, 2026), arXiv:2609.20751.
- Yuchen Zhu and others, FLARE: Diffusion for Hybrid Language Model (preprint, 2026), arXiv:2606.01774.
- Background from before 2026. Aaron Lou, Chenlin Meng and Stefano Ermon, Discrete Diffusion Modeling by Estimating the Ratios of the Data Distribution (ICML 2024), arXiv:2310.16834; Subham Sekhar Sahoo and others, Simple and Effective Masked Diffusion Language Models (NeurIPS 2024), arXiv:2406.07524, the training loss above; Shen Nie and others, Large Language Diffusion Models (preprint, 2025), arXiv:2502.09992, LLaDA 8B from scratch; Marianne Arriola and others, Block Diffusion: Interpolating Between Autoregressive and Diffusion Language Models (ICLR 2025), arXiv:2503.09573.