Image Generation Models: A Practical Comparison
7 min read · updated August 3, 2026
Almost every “best image model” article is a set of cherry-picked outputs from models that have since been replaced. This page does the other thing: the properties that differ between families and survive a version bump, and the method for deciding between candidates on the prompts you will actually send.
Why there is no gallery here
A side-by-side gallery is only evidence if you know the seeds, the sampler, the step count, the resolution, the prompt rewriting the API applied without telling you, and how many generations were discarded before the pictured one. Published galleries almost never state any of it, which makes them a taste sample rather than a comparison. And model versions turn over faster than an article can be revised, so a scoreboard here would be wrong within a quarter.
What does not go stale is the structure. Read the next two sections, then run the protocol on whatever exists when you read this.
Two architectures, different behaviour
Diffusion and flow matching
Start from noise and iteratively denoise toward an image, guided by a text embedding. Diffusion (Ho et al., 2020; Rombach et al.’s 2022 latent diffusion work, which moved the process into a compressed latent space and made it affordable) dominated the field; flow-matching formulations are the more recent framing of the same denoise-a-path idea with a straighter trajectory and fewer steps.
Practical consequences: quality trades against step count, so latency is a dial rather than a constant. The whole image is refined simultaneously, which is excellent for global coherence and is the reason text inside images was historically mangled — glyphs are local, high-frequency structure being refined by a globally-minded process. Seeds are meaningful, so with a fixed seed and sampler the output is reproducible, which matters enormously for evaluation and for iterating on a prompt.
Autoregressive and hybrid
Generate image tokens sequentially with a transformer, in the same manner as text, then decode them to pixels. Because the language model and the image generation share a sequence, these systems tend to follow complex instructions better, handle text-in-image better, and accept conversational editing — “same picture, make the sign green” — as a natural operation rather than a separate API.
The trade is latency that scales with token count and less of the fine-grained sampler control that diffusion users are accustomed to. If you have ever wondered why one product exposes CFG scale, sampler and steps while another exposes nothing but a prompt, this is why.
The axes that decide it
| Axis | Description |
|---|---|
| prompt adherence | Whether all the constraints in a long prompt survive. Test with prompts containing counts, spatial relations and negations — the three that break first. |
| text rendering | Legible words inside the image. The most visible axis of difference between generations of models, and the one that decides most commercial use. |
| editing support | Mask-based inpainting, instruction editing, or nothing. If your workflow is iterative, this outranks raw quality. |
| determinism | Seed control. Without it you cannot A/B a prompt change, because you cannot separate the change from the noise. |
| licensing of output | Who owns it, what the vendor may do with it, whether commercial use is permitted, whether output is watermarked or carries C2PA provenance metadata. |
| safety filter behaviour | Both the false-negative and the false-positive rate matter; see the safety filter page for what benign blocking costs a product. |
| latency and price shape | Per image, per step, or per token, and whether resolution multiplies it. |
| self-hosting | Open-weight models can run on your hardware, which changes the cost curve and removes the filter question entirely — along with its protections. |
For most production decisions the order is: editing support, then text rendering, then licensing, then quality. Quality ranks low not because it does not matter but because the leading candidates are close enough on it that the other three decide the outcome.
A protocol you can actually run
- Write 20 prompts from your own backlog. Not from an article. If you make blog headers, all 20 are blog headers. A model that wins on fantasy landscapes and loses on clean product shots is a loss for you.
- Include the hard categories deliberately. Text in the image; a specific count (“exactly three”); a spatial relation (“the cat to the left of the lamp”); a negation; a specific aspect ratio; a style you must match repeatedly.
- Four generations per prompt per model, seeds fixed and recorded. One sample tells you about the sample, not the model. Four is enough to see variance without becoming a project.
- Record refusals as outcomes. A blocked benign prompt is a product failure and belongs in the results, not in a footnote.
- Log cost and wall-clock per image from the response, not from the pricing page.
Judging without fooling yourself
The scoring step is where these comparisons usually fall apart. Three rules fix most of it.
Blind the images: strip model identity, shuffle, and score in a grid. Knowing which model produced an image is worth a surprising amount of unearned credit, particularly for whichever one you were hoping would win.
Score constraint satisfaction separately from aesthetics. “Are there exactly three birds?” is a binary question with a right answer and it is the one your users will complain about; “is it pretty?” is a taste question that will otherwise swamp it. Keep two columns.
And have at least two people score, then look at where they disagree. Disagreement is not noise to average away — it usually means the prompt was ambiguous, which is a finding about your prompts rather than about the models.