MiniT2I: A Minimalist Baseline for Text-to-Image Generation

01Isn't T2I too hard for us?

On a broad spectrum of conditionality for image generation, class-conditional modeling on ImageNet has long been the default practice: controlled, cheap, and easy to benchmark with FID. However, real-life applications demand a shift toward the rich-conditional side of this spectrum. A classical example is text-to-image (T2I), where the condition transitions from labels to open-ended language. In T2I, the model must follow arbitrary prompts faithfully and deliver high visual quality, not just produce images that look realistic on average. Because the task is so much broader, succeeding at T2I is a much stronger signal that a method genuinely scales — and a more direct reflection of what we actually ask generative models to do.

Yet, shifting to T2I comes with an obvious catch: the nature of the problem makes it feel fundamentally more complicated and demanding than class-conditional generation. That perceived complexity spans everything from intricate model designs to massive compute budgets and heavily engineered data pipelines. Some giants like SD3, FLUX.1-dev, and DALL·E 3, alongside unified generators (Show-o2, BAGEL, OpenUni, Tuna-2, etc.), produce beautiful images — but they charge an intimidating entry fee (Esser et al. 2024; Black Forest Labs 2024; Betker et al. 2023; Xie et al. 2025; Deng et al. 2025; S. Wu et al. 2025; Liu et al. 2026).

So it is natural (and quite ambitious) to ask: Can we make text-to-image feel like ImageNet-level experimentation, with simple architecture, simple data, and a recipe short enough to hold in your head?

This realization led us to MiniT2I: an intentionally plain, pixel-space flow-matching model. Using a simple MM-JiT backbone, readily available data, and an academic-scale compute budget, it reaches the performance frontier of pixel-space diffusion-based T2I systems.

In a nutshell, we were genuinely surprised by how far a minimalist, direct-pixel approach could take us. We hope MiniT2I can serve as a clean baseline for text-to-image generation: small enough to debug, strong enough to reveal real failures, and simple enough to reproduce, modify, and challenge.

The rest of this post replays the project step-by-step: we start by reproducing a standard baseline, drop it into pixel space, fix the sampler, delete the bloat, repair the data — and only then ask where we stand.

02Two minutes of background

Already fluent in diffusion, LDMs, and common T2I practice? Skip ahead.

Flow matching. Flow matching is a diffusion-family algorithm for generative modeling (Ho et al. 2020; Lipman et al. 2022): learn how to transport pure noise into the data distribution. During training, we sample a noisy image on the straight path $z_t = t x + (1 - t)\epsilon$, where $x$ is a real image and $\epsilon$ is Gaussian noise. The model predicts the velocity $v = x - \epsilon$: the direction that walks the noisy sample back toward the real image. With a perfectly learned velocity field, gradually integrating those directions transports random noise into realistic images. For a more formal tutorial, the Cambridge MLG flow-matching introduction is a good place to start.

Latent vs. pixel space. High-resolution images are huge, so latent diffusion made the problem practical by compressing pixels into an autoencoder space, denoising there, and decoding back (Rombach et al. 2022). This works beautifully and dominates much of modern T2I practice, but it comes with reconstruction artifacts and an extra encoder-decoder training stage. JiT showed a different route — stay in RGB, chop the image into large patches, and predict clean pixels so the denoiser survives the high-dimensional target (Li and He 2025).

Architecture for T2I. For T2I, the job is to transfer information from the prompt into the generated image. The usual move is to extract prompt features with a pretrained text encoder, then let text and image tokens share attention while the image is denoised. SD3's MM-DiT is the modern reference: each modality gets its own stream weights, then everything mixes through joint attention (Esser et al. 2024). We dissect its block structure in Section 04. MM-DiT is conceptually simple, but it carries many small design choices worth questioning: which are necessary, and which are just inherited complexity?

Classifier-free guidance. CFG was originally introduced for class-conditional diffusion, where the model is pushed toward a chosen class at inference time; in T2I, the same idea is extended from class labels to text prompts (Ho and Salimans 2022). In formula form, $v_\mathrm{cfg} = v_u + s(v_c - v_u)$, where $v_c$ and $v_u$ are the predictions with and without the condition, and $s$ is the guidance scale. The unconditional branch $v_u$ is trained by randomly dropping the condition during training. ImageNet models often work with scales around 2-3; T2I needs stricter prompt following, so scales around 6 or higher are common.

03The minimum setup

Before touching anything, we set one simple rule: remove every part that seems to be removable. For example, we use no image tokenizer, cascaded generation process, prompt rewriting, RL, or DPO stages. Next, we discuss our choice of data, text encoder, and evaluation benchmarks.

Data. Standard practice today is to train on massive web-scale image-text datasets like LAION-5B or raw CC12M (Schuhmann et al. 2021; Schuhmann et al. 2022; Changpinyo et al. 2021). However, we found that their raw caption quality is intolerably low, which in practice severely slows down the training process. Instead, we rely on a publicly available VLM-recaptioned dataset: LLaVA-recaptioned CC12M.

Detailed recaptioning, however, comes with the cost of much longer sequences. After tokenization, the recaptioned prompts average about 100 tokens — up from less than 20 before recaptioning. We chose a 256-token text budget, which safely covers roughly 99% of the training prompts.

Text encoder. For text, we freeze a FLAN-T5-Large encoder (Chung et al. 2022). At just 341M parameters on the encoder side, it seems tiny and weak compared to the multi-billion-parameter encoders powering frontier T2I systems. However, we tried upgrading it — swapping in T5-XXL, Gemma2-2B, and Qwen3-VL-2B (Gemma Team et al. 2024; Bai et al. 2025) — but the larger models inflated the compute bill far more than they improved the numbers. So T5-L remained our compact yet effective choice.

Evaluations. We report four common benchmarks, each probing a different slice of the problem:

• MSCOCO-30K FID measures distribution-level realism, but never asks whether the image followed the prompt (Heusel et al. 2017; Lin et al. 2014).
• GenEval checks object-level prompt following: existence, count, color, and position (Ghosh et al. 2023).
• DPG-Bench scores long-prompt alignment (Hu et al. 2024).
• PRISM-Bench is the broad stress test we save for the end: text rendering, style, imagination, and entities (Fang et al. 2025).

04The path toward MiniT2I

A strong pixel-space MM-DiT baseline

Our first pixel model was the most straightforward thing we could build: an SD3-style MM-DiT rescaled to our B/32 ablation budget, under 300M trainable generator parameters, with latents swapped for raw pixels (Esser et al. 2024). At 512×512 with 32×32 patches, the image becomes 256 tokens; add 256 text tokens and the whole sequence is 512 tokens, comfortably in the range of ImageNet-scale experiments.

Dropping the codec is an immediate win on compute. The latent B/32 forward costs about 1117 VAE GFLOPs + 262 backbone GFLOPs = 1379 GFLOPs per image; in pixels the codec is gone and the step falls to about 265 GFLOPs. To fit the pixel-space representation, we simply use JiT's timestep sampler and noise schedule.

With this change, the pixel model matches the latent baseline on FID at a fraction of the per-step cost. This was our first useful sign that pixel space itself is not the bottleneck: given the right calibration, it learns about as well as latent space.

GFLOPs are per image per forward for the image-side path. The latent row separates VAE and backbone cost; the pixel row removes the codec. Both use their own tuned noise schedule.

A design choice inherited from (Li and He 2025) turns out to be essential: for high-dimensional pixel-space diffusion, the network should directly predict the clean image, i.e., x-prediction. In high-dimensional pixel space, the loss space and the network's direct output space are separate choices: each can be written in clean-image x, noise ϵ, or velocity v coordinates. This gives nine valid combinations. Holding the B/32 recipe fixed, x-prediction is stable across loss spaces, while direct ϵ- or v-prediction collapses. We therefore use x-prediction with a v-loss throughout MiniT2I.

Measured on the final MiniT2I recipe. MSCOCO FID after 250K CC12M pretraining steps; lower is better. Columns specify the direct network output; rows specify where MSE loss is applied.

MM-JiT: A simple multimodal architecture

With a solid pixel baseline in hand, the next question was where to spend parameters. Starting from the MM-DiT baseline, we made two main architectural changes.

Text adapter blocks. We first add two small text-only Transformer adapter blocks before joint attention. The frozen T5 features are useful, but they were not trained to be consumed by a pixel denoiser, so these adapters give the model a cheap place to reshape the text tokens before they meet image tokens.

Removing AdaLN conditioning. SD3-style MM-DiT conditions on the prompt twice: first through joint attention between image and text tokens, and again through an AdaLN branch that turns pooled text and timestep embeddings into per-block scale, shift, and gate parameters. We found the second route unnecessary for a compact model. MM-JiT keeps the double-stream joint attention, but removes the per-block AdaLN branch; image and text tokens still use modality-specific normalizations and MLPs, and the noise level remains visible from the corrupted image input. This brings the backbone closer to a plain pre-norm Transformer, a design pattern widely used in recent generative Transformer models (Geng et al. 2025b; Lu et al. 2026; Zeng et al. 2026).

B/32 MSCOCO FID after 250K CC12M pretraining steps; lower is better. The architecture gets simpler and learns better, with a modest increase in forward compute.

This improvement started to push the FID close to values seen in existing T2I systems. However, that is when FID stopped telling the truth: although the model posts a respectable score, the samples look soft and averaged, and prompt following is very weak. The model had learned the broad visual world, yet it had not learned what a good answer to a prompt looks like. How can we fix it?

Prompt: "endless book labyrinth illustration for The City of Dreaming Books by walter moers bookshelf dungeon glowing mushrooms scenic light under city underground rustic old place"

Prompt: "fantastical microscopic fairy kingdom photographed by science lab, microscopic art, 8k, UHD"

Prompt: "rain pouring down on a vintage car from 1950 era and trees are in the background of the car"

The fine-tuning stage made it feel like T2I

The fix had nothing to do with architecture. CC12M buys breadth, but what the model never saw was a concentrated diet of images that actually do what their captions say. So we looked for public synthetic datasets that are small enough to overfit on as a fine-tuning set, but high-quality from both the image and caption sides. We ended up with three sources:

Prompt: "endless book labyrinth illustration for The City of Dreaming Books by walter moers bookshelf dungeon glowing mushrooms scenic light under city underground rustic old place"

Prompt: "fantastical microscopic fairy kingdom photographed by science lab, microscopic art, 8k, UHD"

Prompt: "rain pouring down on a vintage car from 1950 era and trees are in the background of the car"

Pretraining only

↓

↓

↓

After alignment fine-tuning

Prompt: "endless book labyrinth illustration for The City of Dreaming Books by walter moers bookshelf dungeon glowing mushrooms scenic light under city underground rustic old place"

Pretraining only

After alignment fine-tuning

Prompt: "fantastical microscopic fairy kingdom photographed by science lab, microscopic art, 8k, UHD"

Pretraining only

After alignment fine-tuning

Prompt: "rain pouring down on a vintage car from 1950 era and trees are in the background of the car"

Pretraining only

After alignment fine-tuning

We fine-tune on this mixture for 40K steps — pretty short compared to the 250K-step pretraining run, but against a 120K-image pool it is a heavy exposure to that high-quality distribution.

The shape should feel familiar from LLM training: pretraining buys coverage, supervised fine-tuning teaches the model what a good answer looks like — same objective, different data, different behavior (Ouyang et al. 2022). The ablation below confirms the division of labor; neither pool can do both jobs. Fine-tuning on more CC12M does nothing for alignment, pretraining on the alignment mix alone collapses coverage, and mixing the two dilutes both.

Another natural question to ask is: how long does each stage need? Both curves answer with a knee. Pretraining FID drops fast and saturates around 250K steps; fine-tuning gains level off around 30-40K. Our default schedule sits right at both knees — training longer buys very little.

05What happens when we scale up?

Every decision so far was made at B/32, our ablation workhorse with its tidy 256 image tokens. The natural next question is whether the same recipe survives a larger setting. B/16 keeps roughly the same parameter count but switches to 16×16 patches, which quadruples the tokens to 1024; L/16 holds that sequence length and grows the generator to 912M parameters. For details, please refer to our code release.

The answer is reassuring: the unchanged recipe trains stably at both settings, and the numbers come out stronger than the B/32 ablation.

GFLOPs are one generator forward per image. FID is read off after CC12M pretraining; GenEval and DPG-Bench after the 40K-step alignment stage.

The larger model also follows prompts more faithfully across multiple domains, as the comparison below shows.

Prompt: "A blackboard sign that says FRESH ROSES above red tulips in clay pots."

B/16L/16

Prompt: "A green ceramic mug with exactly three marshmallows floating in hot chocolate, next to a silver spoon."

B/16L/16

Prompt: "A studio photo of a red cube stacked on top of a blue cylinder, with a green sphere on the right."

B/16L/16

Prompt: "A top-down picnic blanket with four strawberries arranged in a square, a glass of lemonade in the upper left, and a folded map in the lower right."

B/16L/16

Prompt: "A blackboard sign that says OPEN LATE above stacked books."

B/16L/16

Prompt: "A real beaver holding a white mug that has exactly three cute cartoon beavers on the side."

B/16L/16

We must note here that, limited by the current experimental setup, we did not perform a comprehensive scaling study. Both B- and L-sized models share the same data recipe, and we did not scale our model up to real frontier-level compute. We leave a more thorough scaling study for future work.

06Where we stand, where we fail

Benchmarks

Comparing T2I systems head-to-head is a mess: data, tokenizers, text encoders, resolution, sampler settings, and reporting conventions all differ. So, we keep our comparison within pixel-space T2I on 512 resolution.

While achieving strong image-quality benchmark numbers, MiniT2I also uses notably smaller training compute, as shown in the following figure. Without performance optimization, our ablation-level model, MiniT2I-B/32, takes about 3 days on 8 H100s to train; its total denoiser training FLOPs are roughly the same as the default JiT-L/32 ImageNet recipe (Li and He 2025).

However, we must point out that GenEval and DPG-Bench are no longer neutral referees for us. Our own ablations showed that a small alignment mixture swings these scores a lot. In contrast, PRISM-style evaluation and qualitative comparisons are more trustworthy (Fang et al. 2025).

The following table compares MiniT2I with standard industrial models on PRISM-Bench. MiniT2I-L/16 is genuinely respectable on style, composition, and imagination, but still fails at text rendering and named entities — precisely where a public-data recipe like ours runs thin. Improving these two weak spots likely means rebalancing the training data: text rendering can benefit from mixing a small slice of dedicated data such as TextAtlas5M into the alignment stage, as also tested by i1; named entities mostly require scaling up the data coverage (Zeng et al. 2026; Wang et al. 2025a).

Qualitative signal

The visual gap between B/16 and L/16 is easier to see than the benchmark gap. After scaling, short text rendering starts to emerge without specialized fine-tuning, factual prompts become more accurate, and the model handles more art styles and imaginary compositions. For a wider set of L/16 generations, see the MiniT2I-L/16 gallery.

text rendering

style

imagination

knowledge & composition

Compared with a standard T2I model, SD3-Medium (~2B parameters), MiniT2I also shows relatively strong quality on imaginary scenes.

Prompt	SD3-Medium	MiniT2I-B/16	MiniT2I-L/16
A satin jewelry box holding a tiny spiral staircase and glowing blue crystals.
Two figures with spherical heads reading under a tree-library.
Great Wall of China under a Van Gogh-inspired starry sky.
A sunken ship with the large letters VAE visible on the hull.

One caveat is worth spelling out: the alignment stage, analogous to supervised fine-tuning for LLMs, can sharply reduce generation diversity.

Prompt: "An anime illustration of a white rabbit sitting on a grassy field under a starry night sky. The rabbit has big round eyes and fluffy fur. The scene is illuminated by the soft glow of fireflies, creating a magical atmosphere."

MiniT2I-L/16, eight samples

SD3-Medium, eight samples

07Two extensions: LoRA and few-step distillation

A baseline earns its keep when ordinary follow-up tricks still work on it, so we tried two: downstream adaptation via LoRA, and few-step sampling via Mean Flow.

LoRA. The worry with a small model is that it may not contain enough world knowledge to adapt cleanly. So we tried, and the results are surprisingly good. We fine-tune MiniT2I-B/16 on two ~1K-image captioned datasets, Naruto BLIP captions and Pokemon BLIP captions (Hu et al. 2021), attaching adapters to the attention, MLP, and text projection layers and training only the adapters for 400 steps at batch size 16. The style transfers and the prompts keep working.

LoRA transfer examples Naruto BLIP captions

Female ninja

->

Blue hair

->

Pink hair

->

Lightning

->

Brown deer

->

Orange tiger

->

Brown fox

->

Blue and white bird

->

Mean Flow distillation. The default 100-step Euler sampler is fine for research, but it is painful for real interaction. To fix the speed bottleneck, we turned to Mean Flow, a popular distillation method that learns an average velocity field for few-step generation (Geng et al. 2025a). Initializing the student with the teacher's weights, we followed the pixel Mean Flow approach (Lu et al. 2026) to distill MiniT2I-B/16 into a 4-step pixel-space model. The process took just a 50K-step run — a fraction of the teacher's training cost. After distillation, throughput improved by ~50×, while visual quality and benchmark scores held remarkably steady.

The most surprising takeaway was that the distilled quality is largely agnostic to the dataset. When we ran the distillation using our standard pretraining dataset, it achieved approximately the same visual quality but yielded even higher diversity in the generated images.

Throughput is measured on TPU v4-8 with DDP, global batch size 64, and text encoder excluded. The Euler row counts classifier-free guidance as two denoiser evaluations per sampler step.

100-step

->

4-step

astronaut, red flag, floating island

100-step

->

4-step

impressionist sailboats

100-step

->

4-step

miniature planetarium in a walnut shell

100-step

->

4-step

sushi map of the United States

08Discussion

Is pixel-space diffusion promising?

Cautiously, yes. Removing the codec makes the model conceptually clean and puts the raw dimensionality of images directly in play — both the opportunity and the cost of pixel space. At 512×512, we use 16×16 patches for a manageable 1024 image tokens, and the same architecture can be applied at 1024×1024 by simply doubling the patch size. But pushing much further, to 4K and beyond, will still require real engineering: either much longer sequences, larger and harder-to-denoise patches, or more efficient attention. The advantage is not that high resolution becomes free, but that the bottleneck is exposed inside the generator itself, with no separate codec ceiling in the way.

The real challenge is guidance. T2I needs a large CFG scale (around 6 is common practice for both SD3 and our model), and CFG is ultimately a brute-force trick: a linear extrapolation away from the model's own predictions, which can push individual tokens off the data manifold in inconsistent directions. A latent system can hide some of that behind the decoder; in pixel space, the artifacts land directly in the output (as shown in the following figure).

Nevertheless, we believe pixel-space diffusion remains a promising direction, for two reasons. First, it can be truly lossless. A latent generator is upper-bounded by the reconstruction quality of its VAE, and as denoisers grow stronger, that ceiling may become a real bottleneck, especially for image editing, where fine details must survive a round trip through the codec. Second, it collapses training into one stage. The standard practice is two: first train a VAE, then train a denoiser inside its latent space, even though the two stages optimize mismatched objectives; a VAE trained for reconstruction is not necessarily a good space to diffuse in (Skorokhodov et al. 2025). The bet may also extend beyond research (Reve 2026).

Please try MiniT2I!

If this project changed our minds about anything, it is this: text-to-image is now both powerful and accessible. For the compute cost of a few ImageNet runs, we can work on a task that actually reflects the problems industry systems are built around. The broader the task, the harder it is for an idea to survive — and that is exactly why we prefer T2I over class-conditional generation. Most methods that buy a marginal ImageNet FID improvement were never going to transfer to broader vision tasks anyway. T2I catches those fragile ideas early.

The point we most want to land is this: we do not have to — and arguably cannot — "earn" our way to T2I by first perfecting ImageNet FID. And diving into T2I no longer means a painful stretch of trial and error. The baseline is public, and the recipe is short. We hope this work makes T2I feel less like a closed industrial artifact and encourages more research effort to run real experiments on it.

Looking ahead, the biggest unsolved problem is still data. Better alignment data and benchmarks that don't just reward a narrow synthetic aesthetic will do far more for the field than adding another layer of mystery machinery. Beyond that, there are natural extensions for this minimalist approach: direct-pixel image editing without the codec round trip, unified generation/understanding models, and scaling up to video or 3D. Those frontiers will be harder because the data gets noisier and compute requirements rise. But the core message remains: T2I is no longer a walled garden you can only cite from the outside. Please try it, break it, and make the next baseline even simpler!

Acknowledgements

We gratefully acknowledge the Google TPU Research Cloud (TRC) for granting TPU access, and MIT CSAIL for supporting GPU resources. X. Wang, H. Zhao, K. Zhou and L. Ma are supported by the MIT Undergraduate Research Opportunities Program (UROP). We thank Zhengyang Geng, Tianhong Li, Boya Zeng, Qiao Sun, Zhicheng Jiang and Dingning Cao for helpful discussions and feedback.

Citation

@misc{minit2i2026,
  title  = {MiniT2I: A Minimalist Baseline for Text-to-Image Generation},
  author = {Wang, Xianbang and Zhao, Hanhong and Lu, Yiyang and Zhou, Kangyang and Ma, Linrui and He, Kaiming},
  year   = {2026},
  url    = {https://peppaking8.github.io/#/post/minit2i}
}

09References

1. [Esser et al. 2024] Esser, Patrick, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Müller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, Dustin Podell, Tim Dockhorn, et al. 2024. "Scaling Rectified Flow Transformers for High-Resolution Image Synthesis." https://arxiv.org/abs/2403.03206.
2. [Betker et al. 2023] Betker, James, Gabriel Goh, Li Jing, Tim Brooks, Jianfeng Wang, Linjie Li, Long Ouyang, Juntang Zhuang, Joyce Lee, Yufei Guo, Wesam Manassra, Prafulla Dhariwal, Casey Chu, Yunxin Jiao, and Aditya Ramesh. 2023. "Improving Image Generation with Better Captions." https://cdn.openai.com/papers/dall-e-3.pdf.
3. [Black Forest Labs 2024] Black Forest Labs. 2024. "FLUX.1." https://huggingface.co/black-forest-labs/FLUX.1-dev.
4. [Xie et al. 2025] Xie, Jinheng, Zhenheng Yang, and Mike Zheng Shou. 2025. "Show-o2: Improved Native Unified Multimodal Models." https://arxiv.org/abs/2506.15564.
5. [Deng et al. 2025] Deng, Chaorui, Deyao Zhu, Kunchang Li, Chenhui Gou, Feng Li, Zeyu Wang, Shu Zhong, Weihao Yu, Xiaonan Nie, Ziang Song, Guang Shi, and Haoqi Fan. 2025. "Emerging Properties in Unified Multimodal Pretraining." https://arxiv.org/abs/2505.14683.
6. [Liu et al. 2026] Liu, Zhiheng, Weiming Ren, Xiaoke Huang, Shoufa Chen, Tianhong Li, Mengzhao Chen, Yatai Ji, Sen He, Jonas Schult, Belinda Zeng, Tao Xiang, Wenhu Chen, et al. 2026. "Tuna-2: Pixel Embeddings Beat Vision Encoders for Multimodal Understanding and Generation." https://arxiv.org/abs/2604.24763.
7. [Zeng et al. 2026] Zeng, Boya, Tianze Luo, Shu Pu, Jucheng Shen, Taiming Lu, Gabriel Sarch, and Zhuang Liu. 2026. "i1: A Simple and Fully Open Recipe for Strong Text-to-Image Models." https://arxiv.org/abs/2606.11289.
8. [Li and He 2025] Li, Tianhong, and Kaiming He. 2025. "Back to Basics: Let Denoising Generative Models Denoise." https://arxiv.org/abs/2511.13720.
9. [Chen et al. 2025a] Chen, Shoufa, Chongjian Ge, Shilong Zhang, Peize Sun, and Ping Luo. 2025. "PixelFlow: Pixel-Space Generative Models with Flow." https://arxiv.org/abs/2504.07963.
10. [Wang et al. 2025b] Wang, Shuai, Ziteng Gao, Chenhui Zhu, Weilin Huang, and Limin Wang. 2025. "PixNerd: Pixel Neural Field Diffusion." https://arxiv.org/abs/2507.23268.
11. [Rombach et al. 2022] Rombach, Robin, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. 2022. "High-Resolution Image Synthesis with Latent Diffusion Models." https://arxiv.org/abs/2112.10752.
12. [Ho and Salimans 2022] Ho, Jonathan, and Tim Salimans. 2022. "Classifier-Free Diffusion Guidance." https://arxiv.org/abs/2207.12598.
13. [Ho et al. 2020] Ho, Jonathan, Ajay Jain, and Pieter Abbeel. 2020. "Denoising Diffusion Probabilistic Models." https://arxiv.org/abs/2006.11239.
14. [Lipman et al. 2022] Lipman, Yaron, Ricky T. Q. Chen, Heli Ben-Hamu, Maximilian Nickel, and Matt Le. 2022. "Flow Matching for Generative Modeling." https://arxiv.org/abs/2210.02747.
15. [Yu et al. 2026] Yu, Yongsheng, Wei Xiong, Weili Nie, Yichen Sheng, Shiqiu Liu, and Jiebo Luo. 2026. "PixelDiT: Pixel Diffusion Transformers for Image Generation." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 14273-14282. https://openaccess.thecvf.com/content/CVPR2026/html/Yu_PixelDiT_Pixel_Diffusion_Transformers_for_Image_Generation_CVPR_2026_paper.html.
16. [Heusel et al. 2017] Heusel, Martin, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. 2017. "GANs Trained by a Two Time-Scale Update Rule Converge to a Local Nash Equilibrium." https://arxiv.org/abs/1706.08500.
17. [Lin et al. 2014] Lin, Tsung-Yi, Michael Maire, Serge Belongie, Lubomir Bourdev, Ross Girshick, James Hays, Pietro Perona, Deva Ramanan, C. Lawrence Zitnick, and Piotr Dollár. 2014. "Microsoft COCO: Common Objects in Context." https://arxiv.org/abs/1405.0312.
18. [Ghosh et al. 2023] Ghosh, Dhruba, Hanna Hajishirzi, and Ludwig Schmidt. 2023. "GenEval: An Object-Focused Framework for Evaluating Text-to-Image Alignment." https://arxiv.org/abs/2310.11513.
19. [Hu et al. 2024] Hu, Xiwei, Rui Wang, Yixiao Fang, Bin Fu, Pei Cheng, and Gang Yu. 2024. "ELLA: Equip Diffusion Models with LLM for Enhanced Semantic Alignment." https://arxiv.org/abs/2403.05135.
20. [Schuhmann et al. 2021] Schuhmann, Christoph, Richard Vencu, Romain Beaumont, Robert Kaczmarczyk, Clayton Mullis, Aarush Katta, Theo Coombes, Jenia Jitsev, and Aran Komatsuzaki. 2021. "LAION-400M: Open Dataset of CLIP-Filtered 400 Million Image-Text Pairs." https://arxiv.org/abs/2111.02114.
21. [Schuhmann et al. 2022] Schuhmann, Christoph, Romain Beaumont, Richard Vencu, Cade Gordon, Ross Wightman, Mehdi Cherti, Theo Coombes, Aarush Katta, Clayton Mullis, Mitchell Wortsman, Patrick Schramowski, Srivatsa Kundurthy, et al. 2022. "LAION-5B: An Open Large-Scale Dataset for Training Next Generation Image-Text Models." https://arxiv.org/abs/2210.08402.
22. [Changpinyo et al. 2021] Changpinyo, Soravit, Piyush Sharma, Nan Ding, and Radu Soricut. 2021. "Conceptual 12M: Pushing Web-Scale Image-Text Pre-Training To Recognize Long-Tail Visual Concepts." CVPR.
23. [Chen et al. 2025b] Chen, Jiuhai, Zhiyang Xu, Xichen Pan, Yushi Hu, Can Qin, Tom Goldstein, Lifu Huang, Tianyi Zhou, Saining Xie, Silvio Savarese, Le Xue, Caiming Xiong, et al. 2025. "BLIP3-o: A Family of Fully Open Unified Multimodal Models-Architecture, Training and Dataset." https://arxiv.org/abs/2505.09568.
24. [Chen et al. 2025c] Chen, Junying, Zhenyang Cai, Pengcheng Chen, Shunian Chen, Ke Ji, Xidong Wang, Yunjin Yang, and Benyou Wang. 2025. "ShareGPT-4o-Image: Aligning Multimodal Models with GPT-4o-Level Image Generation." https://arxiv.org/abs/2506.18095.
25. [OpenDatasets 2023] OpenDatasets. 2023. "DALL·E 3 Dataset (LAION Discord set)." https://huggingface.co/datasets/OpenDatasets/dalle-3-dataset.
26. [Ouyang et al. 2022] Ouyang, Long, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, et al. 2022. "Training Language Models to Follow Instructions with Human Feedback." https://arxiv.org/abs/2203.02155.
27. [Chung et al. 2022] Chung, Hyung Won, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Yunxuan Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, et al. 2022. "Scaling Instruction-Finetuned Language Models." https://arxiv.org/abs/2210.11416.
28. [Gemma Team et al. 2024] Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, Johan Ferret, Peter Liu, et al. 2024. "Gemma 2: Improving Open Language Models at a Practical Size." https://arxiv.org/abs/2408.00118.
29. [Bai et al. 2025] Bai, Shuai, Yuxuan Cai, Ruizhe Chen, Keqin Chen, Xionghui Chen, Zesen Cheng, Lianghao Deng, Wei Ding, Chang Gao, Chunjiang Ge, Wenbin Ge, Zhifang Guo, et al. 2025. "Qwen3-VL Technical Report." https://arxiv.org/abs/2511.21631.
30. [Ma et al. 2026] Ma, Zehong, Ruihan Xu, and Shiliang Zhang. 2026. "PixelGen: Improving Pixel Diffusion with Perceptual Supervision." https://arxiv.org/abs/2602.02493.
31. [Ma et al. 2025] Ma, Zehong, Longhui Wei, Shuai Wang, Shiliang Zhang, and Qi Tian. 2025. "DeCo: Frequency-Decoupled Pixel Diffusion for End-to-End Image Generation." https://arxiv.org/abs/2511.19365.
32. [Fang et al. 2025] Fang, Rongyao, Aldrich Yu, Chengqi Duan, Linjiang Huang, Shuai Bai, Yuxuan Cai, Kun Wang, Si Liu, Xihui Liu, and Hongsheng Li. 2025. "FLUX-Reason-6M & PRISM-Bench: A Million-Scale Text-to-Image Reasoning Dataset and Comprehensive Benchmark." https://arxiv.org/abs/2509.09680.
33. [Wang et al. 2025a] Wang, Alex Jinpeng, Dongxing Mao, Jiawei Zhang, Weiming Han, Zhuobai Dong, Linjie Li, Yiqi Lin, Zhengyuan Yang, Libo Qin, Fuwei Zhang, et al. 2025. "TextAtlas5M: A Large-scale Dataset for Dense Text Image Generation." https://arxiv.org/abs/2502.07870.
34. [Podell et al. 2023] Podell, Dustin, Zion English, Kyle Lacey, Andreas Blattmann, Tim Dockhorn, Jonas Müller, Joe Penna, and Robin Rombach. 2023. "SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis." https://arxiv.org/abs/2307.01952.
35. [C. Wu et al. 2025] Wu, Chenfei, Jiahao Li, Jingren Zhou, Junyang Lin, Kaiyuan Gao, Kun Yan, Sheng-ming Yin, Shuai Bai, Xiao Xu, Yilei Chen, Yuxiang Chen, Zecheng Tang, et al. 2025. "Qwen-Image Technical Report." https://arxiv.org/abs/2508.02324.
36. [Hu et al. 2021] Hu, Edward J., Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. "LoRA: Low-Rank Adaptation of Large Language Models." https://arxiv.org/abs/2106.09685.
37. [Geng et al. 2025a] Geng, Zhengyang, Mingyang Deng, Xingjian Bai, J. Zico Kolter, and Kaiming He. 2025. "Mean Flows for One-step Generative Modeling." https://arxiv.org/abs/2505.13447.
38. [Geng et al. 2025b] Geng, Zhengyang, Yiyang Lu, Zongze Wu, Eli Shechtman, J. Zico Kolter, and Kaiming He. 2025. "Improved Mean Flows: On the Challenges of Fastforward Generative Models." https://arxiv.org/abs/2512.02012.
39. [Lu et al. 2026] Lu, Yiyang, Susie Lu, Qiao Sun, Hanhong Zhao, Zhicheng Jiang, Xianbang Wang, Tianhong Li, Zhengyang Geng, and Kaiming He. 2026. "One-step Latent-free Image Generation with Pixel Mean Flows." https://arxiv.org/abs/2601.22158.
40. [S. Wu et al. 2025] Wu, Size, Zhonghua Wu, Zerui Gong, Qingyi Tao, Sheng Jin, Qinyue Li, Wei Li, and Chen Change Loy. 2025. "OpenUni: A Simple Baseline for Unified Multimodal Understanding and Generation." https://arxiv.org/abs/2505.23661.
41. [Skorokhodov et al. 2025] Skorokhodov, Ivan, Sharath Girish, Benran Hu, Willi Menapace, Yanyu Li, Rameen Abdal, Sergey Tulyakov, and Aliaksandr Siarohin. 2025. "Improving the Diffusability of Autoencoders." https://arxiv.org/abs/2502.14831.
42. [Reve 2026] Reve. 2026. "Reve." https://x.com/reve/status/2062260665121919101.