The U-Net is gone.
The straight line remains.

A diffusion model has two parts: a fixed recipe that destroys data with noise, and a learned network that predicts what the recipe did. Lesson 10’s network was a U-Net — a convolutional encoder–decoder with skip connections, borrowed from segmentation — and its schedule was a 1000-step ladder of small Gaussian additions. Both choices worked, and both are gone.

The replacements arrived in four steps. DiT (Peebles and Xie, 2023) kept the diffusion loss and swapped the U-Net for a transformer operating on patchified latents. MMDiT(Stable Diffusion 3, 2024) gave text and image their own weight streams and let them meet inside one attention. FLUX (Black Forest Labs, 2024) starts double-stream like SD3 and finishes single-stream to buy depth more cheaply. And the 2025 generation — Z-Image at 6.2B, Qwen-Image at 20.4B — are single-stream and hybrid DiTs at scales where efficiency, not raw size, is the pitch.

Why the swap is not a fashion: a convolution only ever sees a local neighbourhood, so a prompt that says “the red cube is behind the blue sphere” has to survive many layers of stacking before the two objects meet. Self-attention over 256 patch tokens lets every token read every other token in one layer, and the token format is the same one a text encoder emits — which is why the same family of architecture that models language models images.

The shift matters because it is the reason text-to-image became controllable (inpainting, editing and control nets are all the same denoiser nudged in the loop), prompt-accurate (SD3 and SD4 render text in images), and production-fast (a rectified-flow model samples in 20–30 steps, and its distilled sibling in 1–4). Understanding DiT plus rectified flow is understanding the 2026 generative-image stack.

Start from the compressed representation Lesson 11 introduced: a 512×512×3 image is 786,432 values, and a variational autoencoder shrinks it to a 64×64×4 latent — 16,384 values, 48× fewer dimensions. Diffusion operates there. Now cut that latent into non-overlapping patches, flatten each patch into a vector and project it to the model width. A 32×32×4 latent — the size the DiT paper used — becomes 256 tokens of 16 values each, raised to 96 dimensions by one convolution.

This is the ViT trick from Lesson 14, reused verbatim: a Conv2d whose kernel size and stride are the patch size does the cutting and the projecting in one operation. What changes between a ViT and a DiT is only what the tokens are asked to predict — a class label there, a velocity here.

The network has to know two things beyond the noisy latent: how much noise is on it (the timestep) and what it is supposed to draw the text and the class. Both arrive as one conditioning vector. Instead of adding that vector into the tokens, a DiT block uses it to modulate them:

Two properties earn this design its place in every modern diffusion transformer. First, the modulation is per feature, per token: scale, shift and gate are 96-dimensional vectors broadcast across the token sequence, so the block can treat the same token differently at t = 900 and t = 50 — which is exactly what a denoiser needs. Second, the zero initialisation. With scale, shift and gate at zero, the block computes the identity: the LayerNorm still normalises, but the gate multiplies the attention output by zero before it is added back. Gradients then move the block away from doing nothing only when that helps, which is what makes 28-block and 38-block stacks trainable.

Notice the structure: every block has two modulated sublayers, one wrapping attention and one wrapping the MLP, exactly like a pre-norm transformer with two residual adds. A DiT block is a transformer block with the conditioning wired into the normalisation instead of the input.

The idea has an ancestor: FiLM, the feature-wise modulation layers that U-Net diffusion models used to inject the timestep. FiLM also predicts a scale and a shift — but from the timestep alone, applied to a whole feature map, with no gate and no zero initialisation. AdaLN-Zero adds the two details that matter: the modulation is predicted from the full conditioning vector (time plus text, not time alone), and the gate lets the block choose how much of its own output to admit. The first detail is why a DiT does not need cross-attention to obey a prompt; the second is why it is trainable at depth.

A text token from a language model and a patch token from a VAE latent live in different distributions. Forcing them through the same linear layers makes the network spend capacity translating between the two. MMDiT keeps two parallel streams — text tokens in one, image tokens in the other, each with its own projections, its own normalisation and its own MLP — and joins them only inside the attention operation, where every token of one stream can read every token of the other.

That is the whole idea, and it is worth separating from the text encoder story. The encoder decides what the words mean: SD3 uses three of them (two CLIP models plus T5-XXL), and FLUX two (CLIP-L plus T5-XXL). The block decides how those meanings steer the image. T5-XXL alone is ≈4.7B parameters — more than twice the whole 2B SD3 Medium denoiser — so with a DiT at its centre, the prompt-following half of a text-to-image system is not the diffusion model.

Rectified flow changes the sampler, not the conditioning. The classifier-free guidance mix you met in Lesson 11 works identically on a velocity prediction — you mix v instead of ε — and modern models use a lower guidance scale, 3.5–5 rather than 7.5, because a rectified-flow model follows the prompt more tightly without help. The distilled variants drop guidance entirely: FLUX.1-schnell runs at guidance_scale = 0.0 in the source’s four-step snippet.

Here is the whole idea in one line of arithmetic. Take a clean sample x_0 and a noise draw ε. Define a point that slides between them as t goes from 0 to 1: x_t = (1 − t)·x_0 + t·ε. At t = 0 you are holding the data; at t = 1 you are holding pure noise; in between you are on the straight line joining them. That is the entire forward process — no beta schedule, no Markov chain, no cumulative product.

The training target is the direction of that line, v = ε − x_0 — the velocity. It does not change as you move along the line, because the line is straight. The network’s job is to answer one question at any point: which way is the noise? Sample a random t, land on the line, ask, and regress. When you sample, you start from noise at t = 1 and walk down the field with Euler’s method until t = 0:

The interpolation is straight by construction. The model does not get that for free — it has to learn a field whose trajectories are close to straight, and the two labs below show both halves of that sentence. The first puts a measured DDIM path and a measured rectified-flow path side by side with step markers, so you can see where a coarse solver stops short and where the chord-to-path ratio comes from. The second shows the field itself: arrows that start out random and end up pointing from noise to data.

Training is the same five-move loop as ever — zero the gradients, run the forward pass, compute the loss, backprop, step — with the batch replaced by a line through it. Take a batch of clean samples x_0, draw a timestep and a noise field, land on the interpolation at that t, predict the velocity, and score it against the truth. There is no schedule to precompute and no posterior to derive: x_0, ε, t, x_t = (1 − t)·x_0 + t·ε, target ε − x_0, MSE.

Sampling is Euler’s method on that field. Start at pure noise, t = 1, and take steps equal jumps down to zero; each jump asks the model for the local velocity and subtracts a scaled copy. The loop is identical for 4 steps and for 128 — the only thing that changes is dt, and therefore how much the straight-line approximation has to stretch.

This is a dated snapshot, not a leaderboard. The parameter counts come from the tensor metadata on each model card and the licences from the card’s own flag, both read on 16 September 2026. Treat the numbers as examples of the trade-offs, and the links as the source of truth.

Four readings of that table are worth keeping. MMDiT first appeared at 2B. SD3 Medium showed the block, not the scale, was the change. FLUX.1 ships as a pair: dev and schnell are 0.086% apart in parameter count — 11,901,408,320 against 11,891,178,560 — and differ by distillation, which is why one needs 20–30 guided steps and the other 1–4 unguided. Efficiency is a real branch of the tree: Z-Image at 6.2B is roughly half of FLUX.1 and a third of FLUX.2, and it is Apache-2.0. And the text tower is not optional: Qwen-Image’s 20.4B includes a descendant of its own LLM family, the same design choice that made prompt reasoning the selling point.

This is also the lesson’s two deliverables in practice. The variant chooser above is the model-picker decision the source asks you to write down — quality against latency against licence, with the dated numbers attached. The two training functions in chapter 06 are the rectified-flow trainer: a block, a train step and an Euler sampler small enough to hold in your head, and the same three pieces a real training run scales up.

What survives all of this churn is the architecture in this lesson: latents are patchified into tokens, a timestep and a prompt are turned into a scale, shift and gate, transformer blocks predict a velocity, and an ODE solver walks the field back to an image. New models change the envelope — parameters, encoders, distillation, licence — not the shape.