Eight Steps
to a Picture

From Words to Numbers

A neural network can’t read text; it reads numbers. The first thing that happens to your prompt is tokenization — a Qwen2Tokenizer splits your sentence into a sequence of tokens (sub-word chunks) and maps each to an integer ID. Before that, the prompt is wrapped in a short chat template (the <|im_start|>user … <|im_end|> format), because the text encoder is a chat-style language model and expects to be addressed like one. The sequence is capped at 512 tokens, the model’s working budget for how much prompt it will actually read. (A detail that looks like a bug but isn’t: the encoder is from the Qwen3 family but uses the Qwen2 tokenizer — those two generations share tokenizer tooling.)

A Language Model Reads Your Prompt

Those token IDs are fed into a frozen Qwen3-4B language model acting as the text encoder, which turns them into a rich numerical representation — embeddings that capture not just the words but their meaning and relationships. Why an entire 4-billion-parameter LLM, instead of the smaller CLIP or T5 encoders older models used? Because an instruction-tuned LLM brings genuine language understanding: it handles long, compositional prompts, follows instructions, carries real-world knowledge, and — crucially for Z-Image — is strongly bilingual (Chinese and English), which is a big part of why the model is so good at rendering legible text inside images. This single choice is why Z-Image rewards clear, descriptive prompting: there’s a capable reader on the other end of your sentence. (The pipeline reads conditioning from one of the LLM’s near-final hidden layers rather than its very last output — a detail worth confirming in your own environment.)

Starting From Pure Noise

While the text path is running, the image path begins — not from a blank canvas, but from a canvas of pure random noise. A tensor is filled with Gaussian noise, and that noise is the raw material the model will sculpt into a picture. This is exactly where the seed from Experiment 3 enters: the seed determines that random draw. Fix the seed and you fix the starting noise, which is why the same seed reproduces the same image down to the pixel. Change it and you hand the model a different lump of clay to start from, so it carves a different — but still prompt-faithful — result. Everything you saw in the seed experiment traces back to this one tensor.

Compressing the Canvas

Here’s a subtlety that explains several experiments at once: the model does not work on full-resolution pixels — that would be ruinously expensive. It works in a compressed latent space defined by a Variational Autoencoder (the Flux VAE), which represents an image at 1/8th the width and height using 16 channels of information. The noise from Step 3 is sampled directly in this compressed space. (In pure text-to-image there’s no input picture, so the VAE’s encoder is skipped here — it only reappears at the very end, in Step 8, to decode.) That latent grid is then patchified — cut into a grid of small patches (patch size 2), each becoming one token the transformer can process, just like the text tokens from Step 2. The two compression factors compound: 8× from the VAE and 2× from patchification gives 16× total — the reason every height and width must be divisible by 16 (Experiment 4) and a big part of why pushing far above native ~1 MP causes tiling (Experiment 5).

One Stream for Words and Pixels

Now both modalities exist as tokens: text tokens from Step 2, image (noise) tokens from Step 4. Z-Image’s backbone is a Diffusion Transformer (DiT) — the architecture that replaced the older convolutional U-Net by treating image generation as a sequence-processing problem. Its distinguishing choice is being single-stream. In the dual-stream “MMDiT” design used by SD3 and FLUX, text and image tokens are processed by separate sets of weights that only interact through attention. Z-Image instead concatenates text and image tokens into one unified sequence and runs them through a single tower, so the two modalities interact densely at every layer. The argument — inspired by how decoder-only LLMs scale — is that this is far more parameter-efficient, and it’s how a 6.15B model (30 layers, hidden dimension 3840, 32 attention heads) competes with rivals four to thirteen times its size.

Teaching the Model Where Things Are

A transformer treats its input as a set of tokens — it has no inherent sense of which token is where. For an image, position is everything (top-left vs. bottom-right is the difference between a coherent picture and noise). Z-Image solves this with 3D Unified RoPE, a positional encoding scheme that tells each token its place: image tokens are positioned across two spatial axes (height and width), while text tokens are laid out along a separate “temporal” axis. With both kinds of tokens sharing one stream (Step 5), this unified positioning is what keeps words and pixels spatially coherent inside a single sequence — the model always knows what is where.

Eight Passes to Clear the Noise

This is the heart of the model. The transformer’s job, on each pass, is to look at the current noisy latent (plus the text conditioning) and predict how to move it a step closer to a clean image. Z-Image uses flow matching (specifically the rectified-flow idea): instead of the meandering, curved denoising path of older diffusion models, it learns an almost straight-line route from noise to image. Straight routes can be traveled in a few big strides; curved ones need many tiny ones — which is the whole reason modern models can generate in so few steps. The FlowMatchEulerDiscreteScheduler walks that route, taking one stride per step.

Now the two halves of the “Turbo” story come together. Why eight steps: the base Z-Image needs ~100 of these passes. Turbo was created through distillation — a process (Tongyi-MAI calls it Decoupled DMD, refined with reinforcement learning) that trains the fast model to reproduce the slow model’s results in a handful of strides. The target was 8 passes, which is why num_inference_steps=9 is recommended (it works out to 8 actual transformer forward passes) and why Experiment 1 showed quality plateauing right around there. Why guidance is zero: the distillation uses classifier-free guidance as its training engine and effectively bakes the guidance effect into the weights. So at inference there’s no second, unconditional pass to extrapolate from — guidance is already “inside” the model. That’s why the native setting is guidance_scale=0, and why turning it up in Experiment 2 made things worse.

From Latent Back to Pixels

Finally, the VAE decoder — the other half of the autoencoder from Step 4 — takes that clean latent and expands it back into a full-resolution RGB image, restoring the 8× spatial compression and turning 16 abstract channels into the red, green, and blue pixels you actually see. This is the moment the latent becomes a picture. The result is the image you started Part 1 looking at.