Where did text diffusion get to in 2026?

On 19 October, Inception announced Mercury 3. By Inception’s own account it has more than 40 times the parameters of Mercury 1 and decodes about 1,068 tokens a second on NVIDIA GPUs. It is a diffusion language model: it does not write one token after another.

It was not alone. Google DeepMind had released DiffusionGemma as open weights in June, NVIDIA had two diffusion families out, and Ant Group was shipping 100B-parameter diffusion models that edit their own tokens. About two years ago a text diffusion model you could put behind a product was a research question. In 2026 it became a product category.

That is the headline, and it hides the more interesting half. Almost every gain this year came with a catch, and the catches are what the field will spend 2027 on. This part is the map: the year month by month, the bets each lab made, and ten problems that are still open.

The puzzle If you had one year and one GPU cluster to make diffusion language models win, which single problem would you attack first, and why?
My 30-second answer The parallel-decoding wall: committing more of what each pass computes without mixing answers. Most of the other problems hang on that one ratio. On a busy server, the positions a diffusion model computes but does not commit are wasted arithmetic: in the toy model further down, a model that commits 4 of the 32 positions in its block is caught by autoregressive decoding at about 37 users, one that commits 16 of 32 at about 148, and one that commits all 32 is never caught. Fewer passes per answer also make RL rollouts cheaper. I would spend the first month on an evaluation harness, because the wall can only be measured as tokens per pass at matched quality, and the rest training the model on its own decoding trajectories, with a check, in the same pass, on which slots depend on each other.

First, the machine in a few paragraphs, so this part stands on its own.

A diffusion language model starts from a canvas of blanks, called masks, and fills it in over several forward passes (one run of the whole network). Each pass predicts a word for every masked slot at once, and the model commits the slots it is most confident about. The rest stay masked for the next pass.

Take the series’ running example: Name a US city and its most famous bridge. The model has learned two answers equally often, each six tokens long: San Francisco : the Golden Gate and New York : the Brooklyn Bridge. At the start, the slots for “:” and “the” are certain, and every other slot is a coin flip between the two answers.

An autoregressive (AR) model writes the six tokens in six passes. A diffusion model can commit “:” and “the” in pass 1, pick one city word in pass 2, and then everything else is certain, so pass 3 commits the last three. Six tokens in three passes is 2 tokens per forward2 tokens per forward, worked out6 tokens committed ÷ 3 passes = 2AR is 1 by definition: one token per pass., the series’ unit of parallelism (TPFTokens per forward (TPF)Committed tokens per forward pass, averaged over an answer. AR models are exactly 1. It counts tokens kept, not positions computed: a pass over a 32-token block that keeps 4 has a TPF of 4.).

Why is a pass that commits several tokens almost free? Because for one user a pass is limited by reading the weights, not by arithmetic. An 8B-parameter model in bf16 is 16 GB, and an H100 reads 3.35 TB/s, so every pass costs about 4.8 ms4.8 ms, worked out8 × 10⁹ parameters × 2 bytes = 16 GB16 GB ÷ 3,350 GB/s ≈ 0.00478 s ≈ 4.8 ms whether it commits one token or twenty. One token per pass caps a single user at about 209 tokens a second209 tokens a second, worked out1 token ÷ 4.78 ms ≈ 209 per second; twenty per pass gives about 4,1884,188, worked out20 tokens ÷ 4.776 ms ≈ 4,187.5 per second20 × 209 = 4,180 if you round the 209 first..

Nearly every model that shipped this year is a block diffusionBlock diffusionThe answer is written in blocks, left to right. Inside a block the model denoises all positions in parallel; finished blocks are frozen and cached, like an AR model’s past. Block size 1 is an AR model; one block for the whole answer is full diffusion. model, which writes blocks left to right and runs diffusion inside each block. Hold on to two numbers: how many tokens a pass commits, and how many positions it computes. Most of what follows is about the gap between them.

What happened, month by month?

The reading list behind this series collects 72 papers and releases that drew real attention on X between January and October. The figure below has 75 marks75, worked out72 entries on the reading listMercury 2.5 and Mercury 3 share one entry; split, that is 73plus our own two papers: 75: those entries, with Inception’s two releases split apart, plus our own two papers. Each chip sits at its first arXiv date or release date, coloured by the thread it belongs to.

The first five months are diagnosis. In January the Flexibility Trap, which ICML later announced as one of its 2026 Outstanding Papers, argued that letting a model decode in any order makes it worse at reasoning. February brought a block-diffusion drafter for AR models (DFlash), a 100B model that edits its own tokens (LLaDA2.1), and a scaling study suggesting that masking might not be the best noise (Scaling Beyond Masked).

April and May found the reasons. I-DLM traced the quality gap with AR to a model’s disagreement with its own past tokens, Early Decisions showed that the first position a model unmasks steers the whole answer, and continuous diffusion came back with LangFlow, ELF, Cola DLM, hyperspherical flows and RePlaid. March has nothing on the list at all.

June is the peak, with 16 entries, and the second half is when the models arrive: of the entries in the shipped-models thread, 3 fall in January to May and 11 in June to October. TwoTower, iLLaDA, Sumi, DreamReasoner and FLARE land in June; DiffusionGemma’s technical report, NVIDIA’s tri-mode Nemotron and LLaDA2.2 in July; Mercury 2.5 and dQwen3.5 in September; Mercury 3 in October.

Counted by month, the year is lopsided: 28 in the first five months and 47 in the last five28 and 47, worked outJanuary 3 + February 10 + March 0 + April 5 + May 10 = 2875 − 28 = 47 from June to October. The single most liked post on the list was Stefano Ermon’s on the day Mercury 3 launched, at 5,270 likes. The attention followed the products, though many of the ideas inside them (editing, cheap conversion, drafters) were in papers by the spring.

What were the nine threads of the year?

The reading list falls into nine threads, and each of the first eight parts of this series took one or two. Here they are in a paragraph each, with the part that tells the whole story.

The models that shipped (Part 1). DiffusionGemma converts Gemma 4’s mixture-of-experts model (25.2B parameters in total, 3.8B active per token) into a uniform-noise diffusion model with self-conditioning, using under 10% of the AR model’s training tokens. It averages about 20 tokens per forward (19.74 with thinking, 18.76 without) and 1,479 tokens a second on one H100 in FP8, for one request.

NVIDIA’s TwoTower, by its abstract, keeps 98.7% of its AR baseline’s quality at 2.42 times the throughput. Ant’s LLaDA models run at 100B. ByteDance’s iLLaDA (8B, 12T tokens) and Tohoku’s Sumi (7B, 1.5T tokens) showed that training from scratch still works.

Borrowing an autoregressive brain (Part 2). Converting an AR model got cheap: REPR-ALIGN trains up to 4 times faster by aligning hidden states with the frozen AR model, OPDLM needs 15 to 7,000 times fewer tokens, and dQwen3.5 shows that hybrid attention-plus-RNN backbones convert in about half the tokens. Other designs keep the AR model whole: TwoTower, the tri-mode Nemotron, FLARE, CARD, and drafters such as DFlash, JetSpec and Uno.

The parallel-decoding wall (Part 3). Each slot is sampled from its own prediction, so committing two slots that depend on each other in one pass can write “New Francisco”.

The year diagnosed why fast models drift back to left to right (NAP: the training data is sequential), why the first decision matters most (Early Decisions), and why any order can hurt (the Flexibility Trap), then learned orders (SAS), committed earlier (TSD), decoded several blocks at once (Multi-Block) and trained on the model’s own trajectories (PUMBA).

Taking it back (Part 4). In a masked model a committed token is final. LLaDA2.1 added token-to-token edits on top of unmasking, LLaDA2.2 added insert and delete, ProSeCo trained the same network to correct itself, and A2D2 and Set Diffusion made the length of the answer something the model decides.

What the noise should be (Part 5). Masking won on perplexity; 2026 questioned it, and DiffusionGemma ships with uniform noise. Uniform noise beat both masks and AR on GSM8K at 1.7B (with every model decoded left to right), self-conditioning lifted a uniform model from 17.2% to 48.1% (LAW), continuous diffusion reached 8B (Sigma), and binary candidate sets let a slot narrow from several possible tokens to one, like pencil marks in Sudoku.

Thinking without writing (Part 6). Every pass predicts every undecoded slot, and that is computation an AR model never does. Latent tokens measured it, looped layers (LoopMDM, ALoDLM) and register tokens added more of it, and a study of DiffusionGemma asked whether we can still read it: it looks 28.6 times more opaque than Gemma 4, but a token bottleneck between steps brings that to 1.1 times at no cost.

Teaching it to reason (Part 7). RL needs the probability of an answer, and a diffusion model only bounds it. DiPOD keeps the bound tight, JustGRPO fixes the order so the probability becomes exact, our PACT scores the intermediate states instead, and d-OPSD and outcome routing skip the likelihood altogether. UnMaskFork and VGB search over unmasking at test time.

Serving and training systems (Part 8). Caches for finished blocks (our Fixed State paper makes one that stays the same size at any length), memory-traffic fixes (Flash-dLLM), schedulers for busy servers (I-DLM), routing experts per block instead of per token (dMoE: 69.5 to 14.6 experts), exact constrained decoding for JSON, phones (llada.cpp), and block parallelism for long-context training.

Scaling, evaluation and the alternatives (Part 8 and this part). The often-quoted 16 times training-compute gap with AR fell to 3.0 times at block size 4 under a modern protocol. Generative perplexity, the standard quality number, turned out to be easy to game. And Next-Concept Modeling showed that parallel, coarse-to-fine text generation does not have to be diffusion at all.

What did each lab bet on?

Read the year by who made it and the bets are clear, even where the papers are not. I only count what each lab’s own papers and pages say.

labthe betwhat it shipped or published
Inceptionproprietary diffusion at scale, sold on speedMercury 2.5 (September, 1,107 tokens/s on NVIDIA GPUs) and Mercury 3 (October, more than 40× Mercury 1's parameters, 1,068 tokens/s, a 1M-token context). Blog posts, no papers.
Google DeepMindconvert a frontier MoE instead of training a new modelDiffusionGemma: Gemma 4 26B-A4B fine-tuned into a uniform-noise model with self-conditioning, using under 10% of its training tokens; 256-token blocks, about 20 TPF, open weights, still able to run as an AR model.
NVIDIAnever throw the AR model awayTwoTower (a frozen AR tower beside a diffusion tower) and Nemotron-Labs-Diffusion (AR, diffusion and self-speculation in one model, 3B to 14B, with AR mode preferred at high concurrency).
Ant Group (inclusionAI)large MoE diffusion models that editLLaDA2.1 (16B and 100B, token editing, the first large-scale RL for diffusion LMs), LLaDA2.0-Uni (images in the same backbone), LLaDA2.2-flash (100B, insert and delete tokens, 128K context, aimed at agents).
ByteDance Seed and Tohoku NLPfrom scratch is viableiLLaDA (8B, 12T tokens, masked diffusion all the way through fine-tuning), Cola DLM (latent diffusion), Sumi (7B uniform-noise model, 1.5T tokens, data mixture and checkpoints released).
Zyphraconversion on AMD hardwareZAYA1-8B-Diffusion-Preview: about 600B tokens of conversion plus 500B of context extension, blocks of 16, and a theoretical 4.6× speed-up over AR decoding with a lossless sampler, based on acceptance rates, with no wall-clock figure.
universities and smaller labsthe open questions: noise, order, RL, systems, and alternatives to diffusionthe other 61 entries61, worked outthe rows above: Inception 2, Google 1, NVIDIA 2, Ant 3, ByteDance 2, Tohoku 1, Zyphra 1 = 12plus our own 2: 1475 − 14 = 61 in the figure, among them Uno (Institute of Foundation Models), ALoDLM (Amazon) and Next-Concept Modeling (Stanford).

Inception is the only lab betting entirely on a closed model. Its pages give speeds and comparisons, Mercury 3 is claimed to outperform GPT-6 Luna and Claude Haiku 5.5, but no architecture, no parameter count and no paper. Treat those as claims: they may well be right, and nobody outside can check them.

Google’s bet is the cheapest route to a strong model: start from Gemma 4 and spend under a tenth of its token budget. The report is honest about the cost. On AIME 2026, DiffusionGemma scores 69.1 against 84.2 for Gemma 4 in AR mode with thinking, a 15.1-point gap15.1 points, worked outGemma 4 AR, thinking: 84.2DiffusionGemma: 69.184.2 − 69.1 = 15.1On GSM8K the gap is 0.3 points (96.6 against 96.3): conversion loses most on the hardest reasoning., while on GSM8K the two are 0.3 points apart.

NVIDIA’s bet is the most conservative and maybe the most practical: the AR model stays, and diffusion is a mode you switch on. Ant’s is the opposite: go big, go MoE, and fix the mistakes of fast decoding by editing. ByteDance and Tohoku are betting that the field should not depend on AR checkpoints at all, and the academic groups are doing what academic groups do: asking whether the defaults are right.

Which problems are still open?

Here is my list of ten. It comes from reading the year’s papers side by side, and it is one voice among several. For each, the table gives why it matters, the strongest 2026 evidence, and the entries on the reading list that I count as attacking it.

#problemwhy it mattersbest 2026 evidencepapers attacking itpart
1the parallel-decoding walltokens per pass is the whole speed-up, and committing dependent slots together mixes answersLLaDA2.1 Speedy mode: 5.93 TPF against 3.08 at the same average score; DiffusionGemma about 20 TPFFlexibility Trap, NAP, Early Decisions, SAS, TSD, Multi-Block, PUMBA, E-MoE, Residual Context, ORL, latent tokens, IDLM, LLaDA2.13
2serving at high concurrencythe speed-up shrinks as a server fills, then reversesDiffusionGemma beats Gemma 4 with MTP only up to about 32 concurrent usersI-DLM, dMoE, expert-choice routing, Flash-dLLM, constrained decoding, llada.cpp, TwoTower, Nemotron tri-mode, Uno, DiffusionGemma, Fixed State (ours)8
3a likelihood for RLpolicy gradients need log p(answer), which diffusion only boundsDiPOD: Sudoku 25.12% to 97.56% once the bound stays tightDiPOD, Flexibility Trap (JustGRPO), PACT (ours), d-OPSD, outcome routing, LIFT, Block-R1, DreamReasoner, SAS, UnMaskFork, VGB, LLaDA2.17
4knowing a committed token is wrongaggressive commits are only safe if mistakes can be found and fixedI-DLM: LLaDA2.0-flash accepts its own tokens at 0.568, where AR scores 1LLaDA2.1, LLaDA2.2, ProSeCo, I-DLM, VGB, Sumi4
5the right noisethe noise decides what a half-finished canvas can sayGSM8K at 1.7B after fine-tuning, every model decoded left to right: uniform 65.8%, AR 62.9%, masked 58.8%Scaling Beyond Masked, LangFlow, ELF, hyperspherical flows, Cola DLM, RePlaid, AURORA-LM, Sigma, hierarchical joint diffusion, design space, LAW, binary candidate sets, DMD distillation, Sumi5
6length and editingagents and code need inserts, deletes and answers of unknown lengthLLaDA2.2-flash: insert and delete tokens at 100B, 128K contextLLaDA2.2, A2D2, Set Diffusion, CARD, iLLaDA4
7evaluationwithout agreed metrics no comparison across families holdsa sampler cycling through 400 frequent tokens gets generative perplexity 19.6, against 110.5 for MDLMgen-PPL hacking, three coordinates, Scaling Beyond Masked, 16x revisited, dLLM library8
8reading latent computationthe best gains carry hidden state between passes, which oversight cannot seeDiffusionGemma: 28.6× more opaque serial depth than Gemma 4, 1.1× with a token bottleneckHow Transparent is DiffusionGemma, latent tokens, LoopMDM, ALoDLM, register tokens, latent clocks, DLM-Scope6
9training cost, scratch or conversiona diffusion model still costs more to train than an AR onethe 16× compute gap falls to 3.0× at block 416x revisited, REPR-ALIGN, OPDLM, dQwen3.5, FLARE, ZAYA1, iLLaDA, Sumi, DiffusionGemma, CARD, LoopMDM, RePlaid, block parallelism1, 2, 8
10the competitionAR models with diffusion drafters, and non-diffusion parallel generators, chase the same speedUno: up to 3× over its AR base, and 1.5 to 1.6× at the largest batch an H200 fits, with the AR model's outputsDFlash, JetSpec, Uno, Next-Concept Modeling, Nemotron tri-mode, TwoTower, ORL2, 9

The figure lays the same ten problems over the year. Each dot is one entry, and each phase lights the entries attacking the problems it names.

In January, before most of these results, Yunhe Wang and colleagues published a perspective naming ten open challenges of their own. It reports no experiments, but it is a useful second list.

Several of theirs map onto mine: inference-efficient architectures and the cost of many denoising steps at large batch (my serving problem), dynamic output length (my length and editing), data curated for bidirectional learning (NAP’s diagnosis, FLARE’s finding that transfer data matters most), and latent thinking, which they treat as an opportunity and I treat as an oversight problem.

Their list also has problems mine leaves out: structured, multi-scale tokenizers (Next-Concept Modeling is one answer), structured masking, gradient sparsity, diffusion-native prompting, and unified multimodal models (LLaDA2.0-Uni). Mine adds four that theirs does not have: RL, evaluation, transparency and the competition. Those became problems during the year.

Can a model commit more tokens per pass without mixing answers?

This is the wall, and it is the oldest problem on the list. Each pass predicts a distribution for every masked slot on its own, its marginalMarginalThe model’s prediction for one slot by itself, ignoring what the other slots will turn out to be. For slot 1 of the bridge question: San 0.5, New 0.5. The joint is the prediction for the slots together: “San Francisco” 0.5, “New York” 0.5, and “New Francisco” 0.. Committing several slots in one pass samples each from its marginal, as if the slots were independent. When they are not, answers get mixed.

On the bridge question, commit both city words in one pass and you get San York or New Francisco half the time50% wrong, worked outtwo slots, each 50/50: 2 × 2 = 4 equally likely outcomesSan Francisco and New York are real: 2 of 4New Francisco and San York are not: 2 ÷ 4 = 50%. Commit all four uncertain slots and only 12.5%12.5%, worked outfour 50/50 slots: 2⁴ = 16 equally likely outcomesonly 2 are real answers: 2 ÷ 16 = 12.5%k dependent 50/50 slots: 2 ÷ 2ᵏ consistent. of the outcomes are consistent. In one line:

\[p(x_1, x_2) \neq p(x_1)\,p(x_2) \quad \text{when the two slots depend on each other}\]

In words: the probability of the pair is not the product of the two separate probabilities. Every fast sampler is a bet on which slots are independent enough to commit together.

The evidence. The year measured how far the wall has moved. LLaDA2.0-flash averaged 3.08 TPF; LLaDA2.1-flash in its Speedy mode reaches 5.93 at an average score of 72.34 against LLaDA2.0’s 72.43, nearly twicenearly twice, worked out5.93 TPF ÷ 3.08 TPF ≈ 1.93score: 72.34 against 72.43, 0.09 points lower the tokens per pass for the same quality. Multi-Block decoding lifts LLaDA2-Mini from 3.47 to 6.19 TPF with slightly higher accuracy, and DiffusionGemma averages about 20 over its evaluation suite.

NVIDIA’s speed-of-light analysis says there is room left: under an optimal sampler, diffusion could reach up to 76.5% more tokens per pass than self-speculation. And the push to go further keeps hitting quality: Multi-Block combined with DMax reaches 9.34 TPF, with a 1.02% accuracy drop on math and code.

The diagnoses explain why. NAP finds that fast models drift back to left-to-right decoding because their training text is sequential. Early Decisions finds a proximity bias: confidence-based decoding unmasks neighbours of what it already unmasked, so the first position decides the trajectory. The Flexibility Trap finds that any order lets a model skip the hard, uncertain tokens and narrow its range of solutions.

Who is attacking it. Three families of fixes. The first learns the order: SAS treats it as a policy trained with GRPO against a frozen denoiser, lifting Sudoku from 82.0% to 91.8% and GSM8K from 64% to 76% on LLaDA-8B.

The second trains for early commitment: TSD distills earlier predictions toward the final one, and PUMBA trains on the model’s own trajectories and, at matched quality, needs up to 22% fewer passes in full-canvas generation and 26% fewer in block diffusion.

The third carries more than a token from pass to pass. Residual Context Diffusion feeds the discarded predictions back in (4 to 11 points of accuracy), ORL learns that residual on the model’s own trajectories (up to 6.2 times the TPF on a Qwen3-4B conversion), and E-MoE uses the experts’ routing choice as a shared variable that breaks the slot-by-slot sampling. IDLM distills for 4 to 64 times fewer steps.

What a solution would look like. A commit rule that knows which slots depend on each other, so the TPF of a pass is set by the structure of the text rather than by a confidence threshold someone tuned.

The bridge question needs one real choice; a solved sampler would make that choice once and commit the other five tokens around it, every time. It would be reported as TPF at matched quality on a fixed suite, not as a single headline number.

What I am watching for in 2027 (my reading, not a finding). Whether anyone reports TPF above about 10 with no quality loss on hard reasoning, on a model above 30B. Whether shared-variable methods such as E-MoE, so far shown on small benchmarks such as LM1B, survive at scale. And whether a learned order ends up inside a production sampler rather than a paper.

Why does the speed-up shrink on a busy server?

Because the positions a diffusion model computes but does not commit stop being free once the GPU is busy. A toy model, which ignores attention and cache traffic, makes the whole argument.

An H100 does 989 TFLOP/s of dense bf16 arithmetic and reads 3.35 TB/s, so it can do about 295 FLOPs per byte295, worked out989 × 10¹² FLOP/s ÷ 3.35 × 10¹² bytes/s ≈ 295This is the ridge point of the roofline: above it a pass is limited by arithmetic, below it by memory. it reads. A pass costs 2 FLOPs per parameter for each position it processes and reads 2 bytes per parameter, so it stays limited by memory until it processes about 295 positions at once.

An AR server with B users processes B positions per pass and commits B tokens. A block-diffusion server with blocks of 32 that commits 4 tokens per pass processes 32B positions and commits 4B. For one user, diffusion gets about 838 tokens a second against 209838 against 209, worked out32 positions is far below 295: the pass still costs the 4.78 ms weight readdiffusion: 4 tokens ÷ 4.78 ms ≈ 838 per secondAR: 1 ÷ 4.78 ms ≈ 209; 838 ÷ 209 = 4.0, four times faster.

At 16 users diffusion processes 512 positions per pass, past the ridge, and it hits its ceiling of about 7,727 tokens a second7,727, worked outcompute-bound: 989 × 10¹² ÷ (2 × 8 × 10⁹) ≈ 61,800 positions per secondit keeps 4 of every 32: 61,800 × 4 ÷ 32 ≈ 7,727 tokens per second, still 2.3 times AR’s 3,350. AR keeps climbing and catches up at about 37 users37 users, worked outAR below the ridge: B × 209 tokens per secondB × 209 = 7,727 when B ≈ 37Shortcut: ridge × committed ÷ computed = 295 × 4 ÷ 32 ≈ 37.. At 64 users AR does 13,400 tokens a second, and diffusion is at 0.58 times AR.

The shortcut in that box is the rule worth keeping: AR catches block diffusion at about the ridge times the fraction of computed positions that get committed. Commit 16 of 32 and the crossover moves to about 148 users148, worked out295 × 16 ÷ 32 ≈ 148Commit all 32 of 32 and the ceiling equals AR’s own, 61,800 tokens per second: diffusion is never behind.; commit everything and diffusion is never behind. The busy-server problem is the wall again, seen from the server.

The evidence. DiffusionGemma’s report measures what the toy predicts. For one request, in FP8 on one H100, it runs at 1,479 tokens a second against 204 for Gemma 4 and 303 for Gemma 4 with multi-token prediction, about 4.9 times4.9 times, worked out1,479 ÷ 303 ≈ 4.9 against Gemma 4 with multi-token prediction1,479 ÷ 204 ≈ 7.3 against plain AR decoding the faster AR setup. Against Gemma 4 with multi-token prediction it wins on both per-user and total throughput for up to about 32 concurrent users; beyond that the AR model takes over.

A mixture-of-experts model makes it worse. A mixture of expertsMixture of experts (MoE)A layer holding many small feed-forward networks, the experts, of which a router picks a few for each token. Gemma 4 26B-A4B has 128 experts and uses 8 per token, plus one shared expert, so most weights sit idle for any one token. layer routes each token to a few experts, and a 256-token block routes 256 tokens at once. DiffusionGemma touches about 84 different experts per block in each MoE layer, against 8 per token for AR decoding, and its MoE kernel runs 4.3 times slower for it; attention runs 4 times slower too.

The authors say plainly that their kernels and sampling were not tuned for large batches and that an analysis under realistic traffic is future work. That is the honest state of the field: no report on the reading list gives a throughput curve for a production diffusion model under realistic traffic.

Who is attacking it. dMoE routes per block instead of per token: on LLaDA2.0-mini with blocks of 32, the unique experts per layer on MATH500 fall from 70.0 to 16.3, 4.3 times fewer4.3 times fewer, worked out70.0 ÷ 16.3 ≈ 4.3, with accuracy moving from 72.0% to 71.2%, and expert-choice routing balances the load by design.

I-DLM, served with a stationary-batch scheduler, reaches 2.2 to 3.8 times LLaDA-2.1-mini’s throughput at 16 to 32 concurrent requests. Flash-dLLM finds that memory traffic dominates once a cache is in place and fuses the cache kernel: 5.1 and 11.0 times faster than Elastic-Cache on GSM8K and HumanEval.

Long contexts add the cache itself. A bidirectional model cannot keep a normal KV cacheKV cacheThe stored keys and values of tokens already processed, so later passes do not recompute them. An AR model’s past never changes, so its cache is exact. In a bidirectional diffusion model every pass can change every key, so only finished blocks can be cached exactly., so block diffusion caches finished blocks. In our Fixed State paper, at 256k tokens, the attention model has grown to 82 GB of GPU memory and 29 ms per step; a Mamba state cache gives 4.3 times lower latency, 11 times less memory and 14 times the aggregate throughput with batching, where attention cannot run more than one stream.

The other answer is to switch modes with the load. The tri-mode Nemotron runs as AR, as diffusion, or with diffusion drafting for AR. In that last, self-speculation mode its 8B commits 6 times the tokens per forward of Qwen3-8B (2.57 in pure diffusion mode), which the paper turns into 4 times the throughput on SPEED-Bench with SGLang on a GB200, and it recommends AR mode when concurrency is high.

Uno keeps the AR model, beats speculative decoding at every batch size it tested, and reports up to 3 times the base model’s speed, still 1.5 to 1.6 times at the largest batch an H200 fits.

What a solution would look like. Either commit most of what is computed (the wall), or compute fewer positions per pass (Set Diffusion’s flexible sets are one route), or switch to AR-like decoding as the server fills. Any of these would show up as a throughput curve that stays above AR’s from 1 user to a full server.

What I am watching for in 2027 (my reading). A published throughput curve, from 1 to a few hundred concurrent users on named hardware, for a production diffusion model. Mode switching by load inside vLLM or SGLang. And whether DiffusionGemma’s crossover at about 32 users moves once its kernels are tuned.

How do you run RL on a model that cannot score its own answer?

Reinforcement learning for language models needs one number per answer: how probable the model found it. The basic policy gradient is

\[\nabla_\theta J = \mathbb{E}\big[\, R \,\nabla_\theta \log p_\theta(y \mid x) \,\big]\]

In words: push up the log-probability of answers in proportion to their reward. GRPO and its relatives add ratios of new to old probabilities on top. An AR model gives that log-probability exactly, as a sum over its tokens, in one pass.

A diffusion model does not. It gives the ELBOELBOThe evidence lower bound: a quantity a diffusion model can compute that is never above the log-probability of the answer. It averages over the ways the answer could have been unmasked, so it is estimated with random masks and is noisy, and the gap to the true log-probability can change during training., a lower bound that averages over orders of unmasking. On the bridge question, the probability of writing “San Francisco : the Golden Gate” depends on which slot the model fixed first. RL on a bound is RL on a moving, noisy target.

The evidence. DiPOD names the failure: optimizing the bound lets it drift away from the true log-likelihood, and then the gradient drifts too. Adding an on-policy regularizer that keeps the bound tight takes LLaDA-8B-Instruct on zero-shot Sudoku from 25.12% under SPG alone to 97.56%, and Countdown from 51.95% to 80.08%.

The Flexibility Trap takes the opposite route. Fix the order of generation and the likelihood is exact again, so plain GRPO works; their JustGRPO reaches 89.1% on GSM8K while keeping parallel decoding. In our PACT paper we drop the sequence likelihood instead: the model learns a scalar potential that scores every intermediate denoising state, anchored by the final reward.

PACT needs neither likelihood estimates nor ratio clipping, and on LLaDA-8B-Instruct it adds 9.9 points on GSM8K, 12.0 on MATH500, 55.7 on Countdown and 72.6 on Sudoku, the best four-task average reported for this model, 3.7 above the next. It reaches AGRPO’s best GSM8K accuracy in about half the training compute.

Who is attacking it. Beyond these three, d-OPSD conditions a teacher on the model’s own answer as a suffix and beats RL with verifiable rewards in about 10% of its optimization steps.

Outcome-routed training sends each group of rollouts to REINFORCE, teacher supervision or nothing, depending on the verifier’s verdict, and adds 18.31 points on tool calling on top of distillation. LIFT fixes fine-tuning by teaching easy tokens when most of the input is masked and hard ones when context is available.

Block size turned out to matter for post-training as well: in RL, Block-R1 finds that different domains want different block sizes, and in supervised fine-tuning DreamReasoner needed a curriculum from small to large blocks before long chains of thought survived. LLaDA2.1 ran the first large-scale RL on a diffusion model. At test time, UnMaskFork runs tree search over unmasking actions, and VGB backtracks by remasking at a cost that grows quadratically, where best-of-N can grow exponentially.

What a solution would look like. A policy-gradient estimate for any-order generation that is cheap (its cost does not grow with the number of orders) and unbiased, or whose bias is bounded and measured. Or a decision, backed by evidence at scale, that any-order flexibility is not worth having during RL and should be kept for inference only, which is what JustGRPO suggests.

What I am watching for in 2027 (my reading). RL on a diffusion model above 100B with its estimator published and ablated. Whether the likelihood-free methods and the tightened-bound methods converge on one recipe. And RL that trains the editing actions too, which the LLaDA2.1 report lists as future work.

How does a model notice a wrong token, and change the length of its answer?

Two problems that share a cause: the canvas. In a masked model the mask is an absorbing state, so a committed token never changes; and the canvas has a fixed number of slots, so the answer’s length is decided before it is written.

Knowing a token is wrong: the evidence. I-DLM measures how far a model agrees with its own committed tokens when it reads its answer again left to right, its introspective acceptance rate. An AR model scores 1 by construction. On IFEval, SDAR scores 0.699 and LLaDA2.0-flash 0.568. A diffusion model’s committed tokens are often not what the same model would predict, reading its own answer in order.

Editing is the industrial answer. LLaDA2.1 adds token-to-token edits: a low threshold commits a rough draft fast and a second threshold lets confident predictions overwrite committed tokens. That is how its Speedy mode nearly doubles the tokens per pass at the same average score. The same report says the self-correction only partly fixes stuttering (repeated n-grams), and recommends the slower Quality mode for general chat.

ProSeCo trains one network to unmask and to correct its own outputs, up to about 4 times faster sampling than the best-accuracy baseline while beating it. VGB repairs by remasking under a reward. Uniform-noise models such as Sumi, and DiffusionGemma itself, can in principle change any token at any step, since no slot is ever a blank. What none of them has is a cheap, calibrated signal that says “this committed token is wrong” before the damage spreads.

Length: the evidence. DiffusionGemma writes into a 256-token canvas with at most 48 denoising steps, about 12 on average with adaptive stopping, and lists short outputs that limit reasoning depth among its limitations. LLaDA2.2-flash adds DELETE and INSERT control tokens to a 100B model with a 128K context, aimed at agents.

On SWE-bench Verified, LLaDA2.2-flash scores 49.28 against 61.20 for Ling-2.6-flash, the AR model its card compares it with, an 11.9-point gap11.9 points and 1.7 times, worked out61.20 − 49.28 = 11.92 pointsthroughput: 519.0 ÷ 303.2 ≈ 1.7Ling’s score comes from its own report with a different scaffold; LLaDA’s is the average of five runs with the Claude Code scaffold. at 1.7 times the throughput, though the two numbers come from different scaffolds. A2D2 inserts tokens anywhere and fine-tunes insertion and unmasking jointly toward a reward; Set Diffusion decodes flexible sets of positions with cache updates after every step; iLLaDA and CARD generate variable lengths.

What a solution would look like. Two things trained, not bolted on. A same-pass check, like I-DLM’s verification of earlier tokens, that flags a wrong committed token with calibrated confidence. And substitute, insert and delete as first-class actions in the training objective, with a probability attached, so that RL can train them along with everything else.

What I am watching for in 2027 (my reading). An editing model beating an equally fast mask-only model on an agent benchmark under the same scaffold. Calibration curves for edit decisions in a paper. And whether the Top 10 perspective’s “dynamic output length” gets a standard answer, or every lab keeps its own.

What should the noise be, and how would we even tell?

These two belong together, because the noise question cannot be settled until the measuring question is.

The noise: the evidence. A masked slot loses its identity in one event; a uniform-noise slot is replaced by a random token; a continuous slot is an embedding blurred by Gaussian noise; a binary candidate set keeps several still-possible tokens and shrinks. Masking won on perplexity.

Scaling Beyond Masked trained all three families at 1.7B on 2.1T tokens and fine-tuned them on GSM8K: uniform 65.8%, AR 62.9%, masked 58.8%, although the uniform model has the worse perplexity. One caveat matters for a parallel-decoding series: to compare like with like, the paper decoded every model left to right, one token at a time. Google’s DiffusionGemma, the most visible open release of the year, uses uniform noise with self-conditioning rather than masks.

Continuous diffusion came back hard. LangFlow reports perplexity 24.6 on OpenWebText (RePlaid’s authors re-scored its public checkpoint at 32.2, arguing that LangFlow’s estimator drops a term), RePlaid establishes a scaling law with a 20 times compute gap to AR, and Sigma trains 3B and 8B continuous models on par with discrete ones on math and code. ELF stays in embedding space until the last step, hyperspherical flows rotate vectors on a sphere, AURORA-LM and Cola DLM diffuse in a learned latent space, and hierarchical joint diffusion reaches 27.4% on GSM8K.

The ideas bleed across families. The design-space study explains why self-conditioning, feeding a model its own last prediction, which DiffusionGemma also uses, helps: it shows the model inference-like states it rarely sees in training.

The same study’s SemiCat reaches 49.94% on TinyGSM. LAW goes all the way, carrying the expected embedding from step to step and decoding once at the end, and lifts the uniform model Duo from 17.2% to 48.1%. Distribution matching distillation gets a continuous model to generative perplexity 45.6 in 4 steps.

Binary candidate sets beat tuned masked and uniform baselines on Sudoku-Extreme, Boxoban and graph colouring. Sander Dieleman’s August essay argues that continuous models are back mainly because they distill well into few-step samplers. Every one of these comparisons is made at a different scale, on different data, with a different metric.

Evaluation: the evidence. Perplexity is informative within a family and misleading across families, as Scaling Beyond Masked shows. Generative perplexity, the usual stand-in for sample quality, is worse: a sampler that cycles through the 400 most frequent tokens scores 19.6 on OpenWebText, 5.6 times lower5.6 times lower, worked outMDLM: 110.5; the 400-token cycle: 19.6110.5 ÷ 19.6 ≈ 5.6Real OpenWebText text scores 17.1. Lower is supposed to be better. than MDLM and close to real text, while writing nonsense by construction.

The bound itself needs care. The three-coordinates paper proves that the negative ELBO equals the data’s entropy plus a path divergence, and that different papers’ objectives learn the same reverse process in different coordinates, so ELBO values are hard to compare across conventions. The 16 times training gap came partly from scoring with the ELBO: switching to the exact likelihood alone brings it to 12.8 times.

Speed is reported in incompatible units too: TPF (DiffusionGemma’s about 20), tokens a second on a named GPU (its 1,479 on one H100), tokens a second on unnamed “NVIDIA GPUs” (Mercury 3’s 1,068), and a “theoretical speed-up versus AR” computed from acceptance rates (ZAYA1’s 4.6 times, with no wall-clock figure). Dieleman put it bluntly: “a common weakness of diffusion language modelling papers: the evaluation methodology”.

Who is attacking it. The hacking paper proposes a profile instead of one number: judge-model ratings with diversity guardrails, plus distributional measures such as MAUVE and a new compression-based divergence. The dLLM library standardizes training, inference and evaluation pipelines for open models. The 16x paper’s protocol, exact likelihood under the model’s own decoding order, is a model for how to compare fairly.

What a solution would look like. One harness that every family can run: the same downstream tasks after the same fine-tuning, a quality and diversity profile, exact likelihoods wherever a decoding order defines one, and TPF and tokens a second at one user and at a busy batch on named hardware. With that, the noise question becomes an experiment instead of a debate.

What I am watching for in 2027 (my reading). A shared benchmark coming out of the two NeurIPS 2026 diffusion workshops, DiffuLM and BENTO. And one noise comparison at 8B or above with matched data, compute and fine-tuning. Until then, I would not trust any claim that one noise wins.

Can we still read what the model is thinking?

Every pass predicts every undecoded slot, and those predictions shape the tokens that do get written. The latent-tokens paper shows that the decoded token relies on them: ablating them speeds decoding up but hurts quality, and adding them to an AR model through multi-token prediction helps the AR model too. A diffusion model does part of its thinking in a place nobody reads.

The evidence. “How Transparent is DiffusionGemma?” measures it. Its opaque serial depth, the amount of serial computation between states a human can read, first looks 28.6 times higher than Gemma 4’s. Forcing the information between denoising steps through a token bottleneck costs nothing in quality and brings that to 1.1 times. The model is about as monitorable as Gemma 4.

The catch is in the second half of that paper. Algorithmic transparency, reconstructing how the model reached its answer, is harder, because every prediction on the canvas can change at every step: the authors find non-chronological reasoning and smearing of tokens and sequences. And the year’s quality gains mostly carry more hidden state, not less.

LoopMDM loops a few layers, matches same-size models with up to 3.3 times fewer training FLOPs, and ends up to 8.5 points higher on GSM8K. ALoDLM lets hard tokens loop longer and beats its AR baselines on average at 1.7B and 8B. Register tokens carry a fixed-size continuous state across chunks: up to 8.5 points on math and 19.5 on code over carrying text. Residual context, ORL and LAW all pass continuous predictions forward between steps.

Who is attacking it. The transparency study, which also gives the token bottleneck as a design option. Subliminal Clocks finds that models encode how far denoising has gone in their activations even though nobody gives them the timestep, and that steering along that direction shifts their confidence predictably. DLM-Scope trains sparse autoencoders on diffusion models; inserted in early layers they can even lower the loss.

What a solution would look like. Architectures where whatever crosses from one step to the next is either tokens or a small state that probes can read, and a monitorability evaluation reported alongside accuracy for every reasoning model, diffusion or not.

What I am watching for in 2027 (my reading). Whether the token-bottleneck result holds for models that carry continuous state by design, such as register tokens, LAW and ALoDLM. If it does, transparency is a solved engineering choice. If it does not, there is a real trade between the best quality gains and oversight.

Is it cheaper to train from scratch or to convert an AR model?

A widely cited study put the training compute a diffusion model needs to match an AR model’s likelihood at about 16 times. The October paper revisiting it trained about 1,700 models and walked the number down. Re-measured in their setup, the old kind of model needs 17.8 times; scored with its exact likelihood, 12.8 times; with block diffusion and an encoder-decoder at block size 32, 7.8 times; 4.6 times at block 8, and 3.0 times at block 4, a 6-fold cuta 6-fold cut, worked out17.8 ÷ 3.0 ≈ 5.9the steps: 17.8 → 12.8 → 7.8 → 4.6 → 3.0From the published 16: 16 ÷ 3.0 ≈ 5.3..

The catch is in the block size. Decoding one block at a time, a pass can commit at most the whole block, so block 4 means at most 4 tokens per passat most 4, worked outa pass works inside one block of 4 positionsit can commit at most all 4: TPF ≤ 4DiffusionGemma’s 20 TPF needs a much larger block: it uses 256.. Cheap training and high parallelism pull in opposite directions; Multi-Block decoding, which runs several blocks at once, is one way out.

From scratch. iLLaDA trains an 8B masked model on 12T tokens and is competitive with Qwen2.5 7B on several benchmarks. Sumi trains a 7B uniform-noise model on 1.5T tokens, 8 times fewer8 times, worked out12T ÷ 1.5T = 8, and is competitive with AR models trained on comparable budgets on knowledge, reasoning and code, behind on commonsense. Neither is near the scale of the 26B DiffusionGemma or the 100B LLaDA models, and none of the year’s from-scratch papers on the list went past 8B.

By conversion. DiffusionGemma uses under a tenth of Gemma 4’s training tokens and gives up 15.1 points on AIME 2026. I-DLM converts Qwen3-8B with 4.5B tokens and matches its AR model’s quality.

OPDLM needs 15 to 7,000 times fewer training tokens, REPR-ALIGN trains up to 4 times faster, and dQwen3.5’s hybrid backbones reach a given loss in about half the tokens. At the large end, ZAYA1 used about 1.1T tokens1.1T, worked outabout 600B tokens of conversion at 32k contextplus 500B of context extension to 128k: 1.1T and TwoTower about 2.1T by its abstract (its body gives about 1.4T, and 2.02 times rather than 2.42 times the throughput).

FLARE’s finding is the one I would put on a sticky note: the quality of the transfer data matters more than the loss or the attention mask. On the systems side, block parallelism speeds up long-context training and conversion, CARD trains 3 times faster than block diffusion by staying causal, LoopMDM matches same-size models with up to 3.3 times fewer FLOPs, and continuous diffusion still sits at a 20 times gap (RePlaid).

What a solution would look like. A compute-matched comparison at scale: one model trained from scratch and one converted, at the same total FLOPs, evaluated on hard reasoning, where conversion loses most. And a conversion recipe that keeps the AR model’s ceiling on AIME-like problems, not only on GSM8K.

What I am watching for in 2027 (my reading). A from-scratch diffusion model above 30B with its recipe published. The compute gap at block 32 falling below 3 times. And whether the AIME gap of converted models closes.

Will diffusion even be the thing that wins?

The speed that diffusion promises is also available to AR models, through speculative decodingSpeculative decodingA cheap drafter proposes several tokens, and the large AR model checks them all in one pass, keeping the longest prefix it agrees with. The output has exactly the large model’s distribution, so the speed-up is lossless., and 2026 made diffusion the best drafter. That is the competition, and it comes from inside the field.

The evidence. DFlash drafts a whole block in one pass with a small block-diffusion model conditioned on the AR model’s features: over 6 times faster with nothing lost, and up to 2.5 times the speed-up of EAGLE-3. JetSpec finds the catch: a diffusion drafter proposes positions independently, so its candidate trees are individually plausible but mutually inconsistent, New Francisco inside the drafter. A causal parallel draft head reaches up to 9.64 times on MATH-500 and 4.58 times on open conversation.

Uno goes furthest. It keeps the AR model’s weights and adds light diffusion weights that draft several tokens at once, sampled losslessly. It beats speculative decoding at every batch size it tested and runs up to 3 times faster than the base AR model; at the largest batch an H200 fits, its measured gain is 1.5 to 1.6 times (the paper’s summary says up to 2). Its 8B model outperforms the 26B DiffusionGemma and the proprietary Mercury 2 on all its evaluated benchmarks in agentic tool use, coding and long-context reasoning.

The counter-evidence is real too. For one request, DiffusionGemma runs about 4.9 times faster than Gemma 4 with multi-token prediction, and ORL runs 1.74 times faster than DFlash at matched accuracy, serving one request on one H100. The fight is not settled; it is just no longer diffusion against plain AR.

Then there is generation in parallel without diffusion. Next-Concept Modeling encodes text into a hierarchy of codes with a multiscale residual VQ-VAE and generates one level at a time, every code in a level in parallel. It is 21 times faster than the strongest diffusion baseline on LM1B with better generative perplexity, 10 times on OpenWebText, and 31 times on XSum at matched quality. Its generators have about 100M parameters and its scaling results are, in the authors’ word, preliminary.

What a solution would look like. Here “solution” means a fair fight: a diffusion model, an AR model with a diffusion drafter, and a coarse-to-fine model, at matched quality, at 8B or above, on the same hardware, measured from one user to a full server. Until that exists, each camp wins its own benchmark.

What I am watching for in 2027 (my reading). Whether Uno-style lossless drafting holds up at frontier scale, since it would let a lab keep its AR model and still get most of the speed. Whether Next-Concept Modeling scales past 1B. And which of these ends up as the default in serving stacks, because defaults decide what most people actually run.

What numbers should you carry out of this series?

The series’ estimates fit on one page. Each row is something you can redo in your head, with the part where it was first worked out.

The canvas.

what number how it is worked out part
passes for the 6-token bridge answer AR 6; confidence schedule 3; smarter schedule 2 commit the certain slots, make the one real choice, then the rest are certain 1
tokens per forward 2, or 3 with the smarter schedule 6 ÷ 3; 6 ÷ 2 1
two dependent 50/50 slots in one pass 50% wrong 2 real outcomes of 2² = 4 3
four dependent 50/50 slots in one pass 12.5% consistent, 87.5% mixed 2 of 2⁴ = 16; in general 2 ÷ 2ᵏ 3

The hardware.

what number how it is worked out part
weight read, 8B model in bf16, H100 4.8 ms per pass 16 GB ÷ 3,350 GB/s 1
one user, one token per pass about 209 tokens/s 1 ÷ 4.78 ms 1
one user, 20 tokens per pass about 4,188 tokens/s 20 ÷ 4.776 ms 1
the ridge 295 FLOPs per byte 989 TFLOP/s ÷ 3.35 TB/s 8
AR’s compute-bound ceiling about 61,800 tokens/s 989 × 10¹² ÷ (2 × 8 × 10⁹) 8

The busy server (toy model: block 32, 4 tokens committed per pass, attention and cache traffic ignored).

users AR tokens/s diffusion tokens/s diffusion ÷ AR part
1 209 838 4.0× 8
8 1,675 6,700 4.0× 8
16 3,350 7,727 2.3× 8
37 7,747 7,727 about 1× 8
64 13,400 7,727 0.58× 8
295 and up about 61,800 7,727 0.13× 8
what number how it is worked out part
diffusion’s ceiling 7,727 tokens/s 61,800 × 4 ÷ 32 8
where AR catches up about 37 users ridge × committed ÷ computed = 295 × 4 ÷ 32 9
the same, committing 16 of 32 about 148 users 295 × 16 ÷ 32 9

What the papers measured.

what number how it is worked out part
DiffusionGemma 19.74 TPF with thinking, 18.76 without; 1,479 tokens/s on one H100 in FP8, one request averaged over its suite, as reported 1
DiffusionGemma against Gemma 4 with MTP 4.9× for one request; AR wins past about 32 users 1,479 ÷ 303; the crossover as reported 9
LLaDA2.1 Speedy mode 1.9× the TPF at the same score 5.93 ÷ 3.08, at 72.34 against 72.43 4
Multi-Block on LLaDA2-Mini 3.47 → 6.19 TPF as reported, with slightly higher accuracy 3
Nemotron-Labs-Diffusion-8B 6× Qwen3-8B’s tokens per forward in self-speculation mode; 2.57 in pure diffusion as reported, at comparable accuracy 1
unique experts per layer, block of 32 (dMoE, MATH500) 70.0 → 16.3, 4.3× fewer 70.0 ÷ 16.3 8
our Fixed State cache at 256k tokens attention 82 GB of peak GPU memory (weights included), 29 ms per step; Mamba 4.3× lower latency, 11× less memory as reported 8
opaque serial depth, DiffusionGemma 28.6× Gemma 4’s, 1.1× with a token bottleneck as reported 6
DiPOD on Sudoku 25.12% → 97.56% SPG alone, then SPG with DiPOD 7
the training-compute gap 16× published, 17.8× re-measured → 12.8× → 7.8× → 4.6× → 3.0× exact likelihood; block 32 with encoder-decoder; block 8; block 4 8
training tokens DiffusionGemma under 10% of Gemma 4’s; iLLaDA 12T; Sumi 1.5T as reported; 12T ÷ 1.5T = 8 1, 2

Four drills, each under a minute with the rules above. Say the answer before opening it.

drillsin your head
  1. A diffusion server uses blocks of 64 and commits 8 tokens per pass, with the same 8B model on an H100. At about how many users does AR catch up?

    answer

    About 37 again: the rule is ridge × committed ÷ computed, and 295 × 8 ÷ 64 is the same 295 ÷ 8 as before. A bigger block with the same committed fraction buys nothing on a busy server; only the fraction matters.

  2. A sampler commits three dependent 50/50 slots of a two-answer question in one pass. How often is the result consistent?

    answer

    2 of 2³ = 8 outcomes are real answers, so 25%. Each extra dependent slot halves it again.

  3. A block-diffusion model is trained at block 4 because the compute gap there is only 3.0×. What is the most tokens per pass it can commit decoding one block at a time, and what does that mean for a single user on an H100?

    answer

    At most 4, so at most 4 ÷ 4.78 ms ≈ 838 tokens a second for an 8B model, four times AR. DiffusionGemma's 20 tokens per pass would be out of reach without decoding several blocks at once.

  4. Your model commits 4 of 32 positions per pass, and you can either double the committed tokens or halve the block. Which moves the crossover with AR further out?

    answer

    They do the same thing: 8 of 32 and 4 of 16 are both a quarter, so both move the crossover from about 37 to 295 ÷ 4 ≈ 74 users. Halving the block is cheaper to build, but it also halves the most a pass can ever commit.

Rapid fire: can you do these from memory?

  1. Why does committing two dependent slots in one pass write "New Francisco", and how often does it happen with two 50/50 slots? With four?
  2. In the toy server model, where does AR catch block diffusion that commits 4 of 32 positions, and what single ratio moves that point?
  3. What did LLaDA2.1's Speedy mode buy in tokens per forward, at what cost in score, and what did its editing not fix?
  4. Why can't GRPO be applied to a masked diffusion model as it stands? Name three ways 2026 papers got around it.
  5. What is introspective acceptance, and what did I-DLM measure for an AR model and for LLaDA2.0-flash?
  6. Why is generative perplexity a weak quality metric? What simple sampler beat trained models on it?
  7. Walk the 16× training-compute gap down to 3.0×. What do you give up at block size 4?
  8. Name one AR model with a diffusion drafter and one non-diffusion parallel generator, with their headline speed-ups and their catches.

Where can you go deeper?

The essays and talks that shaped the year (from the series’ reading list).

  • Volodymyr Kuleshov and the Cornell group, “How to Build a Diffusion Language Model” (2026-07-08), thread. The research behind Mercury, Gemma Diffusion and Nemotron Diffusion, from the group behind MDLM, block diffusion and Duo.
  • Sander Dieleman, on continuous diffusion language models (2026-08-24), blog. Why continuous diffusion is back, and why evaluation needs fixing.
  • Junbo Zhao, “Some Theoretical and Practical Thoughts on Diffusion Language Models” (2026-08-09), discussed by Dimitri von Rütte and Sander Dieleman. Where discrete diffusion stands, from the LLaDA lead.
  • Dimitri von Rütte, “Why Diffusion Language Models Are the Future” (2026-02-27), thread. The argument from Sudoku-like problems.
  • Varun Neal, “Diffusion will be everywhere” (2026-10-01), thread. The optimist’s case.
  • Nathan Barry on noising processes and on KV drift (2026-01-15 and 2026-06-28), first and second thread.
  • Zhuokai Zhao, a map of the diffusion RL literature (2026-03-22), thread.
  • Chenfeng Xu on why AR is simple to serve (2026-04-14), thread. The introspective-consistency argument in plain words.
  • Subham Sekhar Sahoo, Stefano Ermon and colleagues, NeurIPS 2026 tutorial “The Principles of Diffusion Models: Toward Fast and Scalable Diffusion LLMs” (announced 2026-10-22), post.
  • Yunhe Wang et al., Top 10 Open Challenges Steering the Future of Diffusion Language Model and Its Variants (perspective, 2026), arXiv:2601.14041. The January roadmap of ten challenges and four pillars.

Our own papers.

  • Vaibhav Singh, Pierre-André Noël, Torsten Scholak, Eugene Belilovsky and Oleksiy Ostapenko, Fixed State, Long Reach: What a Constant-Size Cache Buys Block Diffusion at Scale (preprint, 2026), arXiv:2609.11998.
  • Vaibhav Singh and Eugene Belilovsky, RL Post-Training Diffusion Language Models Along Their Own Generation Paths (PACT) (preprint, 2026), arXiv:2610.17266.

The releases without papers. Inception’s Mercury 2.5 and Mercury 3 posts, Zyphra’s ZAYA1-8B-Diffusion-Preview, and Ant’s LLaDA2.2-flash model card (code).

The models that shipped.

  • DiffusionGemma Team, DiffusionGemma Technical Report (technical report, 2026), arXiv:2608.00146. page
  • Fitsum Reda et al., Nemotron-Labs-TwoTower: Diffusion Language Modeling with Pretrained Autoregressive Context (preprint, 2026), arXiv:2606.26493. page
  • Yonggan Fu et al., Nemotron-Labs-Diffusion: A Tri-Mode Language Model Unifying Autoregressive, Diffusion, and Self-Speculation Decoding (preprint, 2026), arXiv:2607.05722.
  • Tiwei Bie et al., LLaDA2.1: Speeding Up Text Diffusion via Token Editing (preprint, 2026), arXiv:2602.08676. page
  • Inclusion AI, LLaDA2.0-Uni: Unifying Multimodal Understanding and Generation with Diffusion Large Language Model (preprint, 2026), arXiv:2604.20796. page
  • Shen Nie et al., Improved Large Language Diffusion Models (preprint, 2026), arXiv:2606.25331. page
  • Mengyu Ye et al., Sumi: Open Uniform Diffusion Language Model from Scratch (preprint, 2026), arXiv:2606.19005. page · code
  • Zirui Wu et al., DreamReasoner-8B: Block-Size Curriculum Learning for Diffusion Reasoning Models (preprint, 2026), arXiv:2606.19257. page
  • Anton Xue et al., dQwen3.5: Hybrid-Attention Diffusion Language Models (preprint, 2026), arXiv:2609.20751.
  • Yuchen Zhu et al., FLARE: Diffusion for Hybrid Language Model (preprint, 2026), arXiv:2606.01774.

The parallel-decoding wall.

  • Zanlin Ni et al., The Flexibility Trap: Rethinking the Value of Arbitrary Order in Diffusion Language Models (preprint, 2026; announced by ICML as a 2026 Outstanding Paper), arXiv:2601.15165. page · code
  • Pengxiang Li et al., Why Diffusion Language Models Struggle with Truly Parallel (Non-Autoregressive) Decoding? (preprint, 2026), arXiv:2602.23225. page
  • Jiyeon Kim et al., Early Decisions Matter: Proximity Bias and Initial Trajectory Shaping in Non-Autoregressive Diffusion Language Models (preprint, 2026), arXiv:2604.10567.
  • Jiawei Xu et al., Scheduling Thoughts: Learning the Order of Thought in Diffusion Language Models (preprint, 2026), arXiv:2606.23567. page
  • Shijian Xu et al., Temporal Self-Distillation: Faster Inference in Discrete Diffusion Language Models (preprint, 2026), arXiv:2609.15177.
  • Yijie Jin et al., Multi-Block Diffusion Language Models (preprint, 2026), arXiv:2606.29215. page · code
  • Manuel Madeira et al., On Trajectory-Aware Training for Masked Diffusion Language Models (preprint, 2026), arXiv:2609.37974.
  • Arseny Ivanov et al., E-MoE: Enhanced Mixture-of-Experts for Non-Factorized Diffusion Language Models (preprint, 2026), arXiv:2609.37533. page
  • Yuezhou Hu et al., Residual Context Diffusion Language Models (preprint, 2026), arXiv:2601.22954. page · code
  • Yifan Yu et al., On-Policy Residual Learning for Diffusion Language Models (preprint, 2026), arXiv:2610.20687.
  • David Li et al., IDLM: Inverse-distilled Diffusion Language Models (preprint, 2026), arXiv:2602.19066. page
  • Andre He et al., Reasoning with Latent Tokens in Diffusion Language Models (preprint, 2026), arXiv:2602.03769.

Serving.

  • Yifan Yu et al., Introspective Diffusion Language Models (preprint, 2026), arXiv:2604.11035. page · code
  • Sicheng Feng et al., dMoE: dLLMs with Learnable Block Experts (preprint, 2026), arXiv:2605.30876. page · code
  • Shuibai Zhang et al., Expert-Choice Routing Enables Adaptive Computation in Diffusion Language Models (preprint, 2026), arXiv:2604.01622. page
  • Quan Nguyen-Tri et al., Flash-dLLM: IO-Aware KV Caching and Parallel Decoding for Fast, Memory-Efficient Diffusion LLMs (preprint, 2026), arXiv:2609.26796. page · code
  • Meihua Dang and Stefano Ermon, Constrained Decoding for Diffusion Language Models via Efficient Inference over Finite Automata (preprint, 2026), arXiv:2607.07026.
  • Tuowei Wang et al., Efficient On-Device Diffusion LLM Inference with Mobile NPU (preprint, 2026), arXiv:2606.13740.

A likelihood for RL.

  • Haozhe Jiang et al., DiPOD: Diffusion Policy Optimization without Drifting Apart (preprint, 2026), arXiv:2606.13795. page
  • Yifu Luo et al., Learning from the Self-future: On-policy Self-distillation for dLLMs (preprint, 2026), arXiv:2606.18195. page
  • Wentao Lu et al., Outcome-Routed Distillation and Reinforcement Learning for Diffusion Language Models (preprint, 2026), arXiv:2610.19271.
  • Shubham Parashar et al., Learnability-Informed Fine-Tuning of Diffusion Language Models (preprint, 2026), arXiv:2605.22939. page
  • Yan Jiang et al., Block-R1: Rethinking the Role of Block Size in Multi-domain Reinforcement Learning for Diffusion Large Language Models (preprint, 2026), arXiv:2605.11726. page
  • Kou Misaki and Takuya Akiba, UnMaskFork: Test-Time Scaling for Masked Diffusion via Deterministic Action Branching (preprint, 2026), arXiv:2602.04344. page
  • Kijung Jeon et al., VGB for Masked Diffusion Model: Efficient Test-time Scaling for Reward Satisfaction and Sample Editing (preprint, 2026), arXiv:2606.28301.

Wrong tokens, length and editing.

  • Yair Schiff et al., Learn from Your Mistakes: Self-Correcting Masked Diffusion Models (preprint, 2026), arXiv:2602.11590. page
  • Sophia Tang et al., A2D2: Fine-Tuning Any-Length Discrete Diffusion for Adaptive Decoding (preprint, 2026), arXiv:2606.13565.
  • Marianne Arriola and Volodymyr Kuleshov, Set Diffusion: Interpolating Token Orderings Between Autoregression and Diffusion for Fast and Flexible Decoding (preprint, 2026), arXiv:2607.01775. page
  • Junhao Ruan et al., Causal Autoregressive Diffusion Language Model (preprint, 2026), arXiv:2601.22031.

The noise.

  • Subham Sekhar Sahoo et al., Scaling Beyond Masked Diffusion Language Models (preprint, 2026), arXiv:2602.15014. page
  • Yuxin Chen et al., LangFlow: Continuous Diffusion Rivals Discrete in Language Modeling (preprint, 2026), arXiv:2604.11748. page · code
  • Keya Hu et al., ELF: Embedded Language Flows (preprint, 2026), arXiv:2605.10938. page
  • Justin Deschenaux and Caglar Gulcehre, Language Modeling with Hyperspherical Flows (preprint, 2026), arXiv:2605.11125.
  • Hongcan Guo et al., Continuous Latent Diffusion Language Model (preprint, 2026), arXiv:2605.06548. page · code
  • Zhihan Yang et al., Continuous Diffusion Scales Competitively with Discrete Diffusion for Language (preprint, 2026), arXiv:2605.18530.
  • Jiajun Liang et al., AURORA-LM: Autoencoding Unified Representation for Continuous-Latent Diffusion Language Modeling (preprint, 2026), arXiv:2608.02602. page · code
  • Zhihan Yang et al., Large Language Continuous Diffusion Models (preprint, 2026), arXiv:2610.02665.
  • Mathias Ollu and Nikos Komodakis, Denoising Hierarchical Representations: Joint Continuous Diffusion for Language Modeling (preprint, 2026), arXiv:2610.08738. page
  • Oscar Davis et al., On the Design Space of Continuous Diffusion Language Models (preprint, 2026), arXiv:2610.13834.
  • Adrien Deschenaux et al., Loopholing All the Way: Language Modeling with pure Self-Conditioning (preprint, 2026), arXiv:2610.30068. page
  • Rodrigo Casado Noguerales et al., Binary Discrete Diffusion: Candidate-Set Diffusion for Logic and Planning Tasks (preprint, 2026), arXiv:2610.28543.
  • Paul Le Van Kiem et al., Distribution Matching Distillation for Continuous Diffusion Language Models (preprint, 2026), arXiv:2609.40235.

Evaluation.

  • Antonio Franca and Alexander Tong, Hacking Generative Perplexity: Why Unconditional Text Evaluation Needs New Metrics (preprint, 2026), arXiv:2606.08417.
  • Rodrigo Casado Noguerales et al., What Does a Discrete Diffusion Model Learn? One Reverse Process in Three Coordinates (oral at the NeurIPS 2026 workshop “Diffusion Language Models: Foundations, Efficiency, and Reasoning”), arXiv:2607.05381.
  • Zhanhui Zhou et al., dLLM: Simple Diffusion Language Modeling (preprint, 2026), arXiv:2602.22661. page

Latent computation and transparency.

  • Joshua Engels et al., How Transparent is DiffusionGemma? (preprint, 2026), arXiv:2606.20560.
  • Sanghyun Lee et al., Looped Diffusion Language Models (preprint, 2026), arXiv:2605.26106.
  • Liancheng Fang et al., ALoDLM: Adaptively Looped Diffusion Language Models (preprint, 2026), arXiv:2610.04198. page · code
  • Albert Ge et al., Register Tokens for Bounded-State Reasoning in Diffusion Language Models (preprint, 2026), arXiv:2609.16372. page
  • Maximo Eduardo Rulli et al., Subliminal Clocks: Latent Time Modelling in Diffusion Language Models (preprint, 2026), arXiv:2607.01774.
  • Xu Wang et al., DLM-Scope: Mechanistic Interpretability of Diffusion Language Models via Sparse Autoencoders (preprint, 2026), arXiv:2602.05859.

Training cost and conversion.

  • Guanghan Wang et al., Revisiting the 16x Pretraining Compute Gap between Diffusion and Autoregressive Language Models (preprint, 2026), arXiv:2610.17590. page
  • Fred Zhangzhi Peng et al., Don’t Retrain, Align: Adapting Autoregressive LMs to Diffusion LMs via Representation Alignment (preprint, 2026), arXiv:2605.06885. page
  • Xingyu Su et al., Data-Efficient Autoregressive-to-Diffusion Language Models via On-Policy Distillation (preprint, 2026), arXiv:2606.06712. page · code
  • Tarun Suresh et al., Block Parallelism For Efficient Distributed Long-Context Diffusion Language Model Training (preprint, 2026), arXiv:2609.19242. page

The competition.

  • Jian Chen, Yesheng Liang and Zhijian Liu, DFlash: Block Diffusion for Flash Speculative Decoding (preprint, 2026), arXiv:2602.06036. page · code
  • Lanxiang Hu et al., JetSpec: Breaking the Scaling Ceiling of Speculative Decoding with Parallel Tree Drafting (preprint, 2026), arXiv:2606.18394. page · code
  • Subham Sekhar Sahoo et al., Unlocking Lossless Speedups in LLMs via Discrete Diffusion (preprint, 2026), arXiv:2609.04010. page · code
  • Hermann Kumbong et al., Next-Concept Modeling: Fast, Parallel Coarse-to-Fine Text Generation (preprint, 2026), arXiv:2610.14162. page · code