AI image generation achieves a 1000% speedup without training. The method: the most concise "three-stage pipeline"

AI image generation capabilities are growing increasingly powerful, but users still sum up their experience in one word: slow.

For a 1024-resolution image, from entering a prompt to generating the final output, diffusion models typically require repeated sampling in high-resolution space. While quality has improved, waiting times have also risen. The more capable the model, the higher the inference cost.

Among mainstream acceleration methods for traditional diffusion models, techniques such as quantization and efficient attention heavily depend on hardware co-optimization; step distillation relies on costly fine-tuning and often suffers from training instability; feature caching methods require dynamic identification and caching of intermediate features, with acceleration ratios rarely exceeding 5x.

Is it possible to directly boost image generation speed without relying on specific hardware, distilling or fine-tuning the model, or performing dynamic recognition during runtime?

A research team from Beihang University, NTU, and ETH Zurich recently conducted a remarkably straightforward experiment:

First draft at low resolution, then upscale, and finally add a high-resolution refinement pass.

MrFlow (Multi-Resolution Flow Matching) uses this three-stage pipeline to compress end-to-end generation time on models like Qwen-Image from 49.32s to 4.77s, achieving a practical 10.35x speedup.

The paper immediately reached Hugging Face Daily Papers on its release day; within three days, the GitHub repository gained over 200 stars; and it has now climbed to Hugging Face Trending Papers.

Meanwhile, community creators have already begun experimenting with, discussing, and extending MrFlow:

Returning to MrFlow itself, why can such a simple pipeline deliver an order-of-magnitude 10x end-to-end acceleration?

Understanding the Sources of Acceleration

MrFlow's default high-acceleration configuration is 12+1:

• 12 sampling steps in the low-resolution stage
• Only 1 inference step in the high-resolution stage

In native high-resolution generation, the heaviest computational load falls on high-resolution sampling. MrFlow shifts the majority of this workload to the low-resolution stage, reserving the high-resolution pass only for short-range detail refinement. The overhead of additional steps like VAE processing, super-resolution, and noise preparation is minimal, resulting in an overall end-to-end speedup of over 10x even when accounting for all extra operations.

Generation Performance at a Glance

Under 10x-level acceleration, MrFlow consistently produces sharp, clean images, with quantitative metrics showing performance gaps controlled within approximately 1%.

Example on Qwen-Image (10.3x speedup):

Example on FLUX.1-dev (8.25x speedup):

Why Use Multi-Resolution Stages?

Analyzing the design rationale: The inherent spatial structure of images enables this simple yet efficient resolution-reduction generation approach. Elements like main subjects, their positions, poses, compositional reasonableness, and overall semantic alignment with the prompt do not necessarily need to be computed entirely from scratch in high-resolution space. Lower resolution barely compromises core semantic information, preserves overall spatial structure, and reduces the number of image tokens quadratically.

MrFlow seizes this opportunity: First generate the structure cost-effectively, then refine the details at the end. These two phases can be directly connected using a pre-trained super-resolution model.

Step-by-Step Implementation Details

Step 1: Low-Resolution Structure Generation

First, the original model generates an image in low-resolution latent space. This step handles global structure: subjects, layout, semantics, and color atmosphere.

The advantages of low-resolution are straightforward:

• Image tokens are reduced quadratically, making every single step computationally cheaper
• Low-frequency structures converge more easily, allowing fewer total steps

Step 2: Super-Resolution in Pixel Space

Next, the low-resolution result is decoded into pixel space and upscaled to increase resolution.

A critical choice here: Upscale directly in pixel space rather than in latent space.

While upsampling in latent space may seem convenient, it often introduces subsequent issues like local blurriness, texture distortion, and structural corruption. Pixel-space super-resolution is more like continuing to refine a well-defined composition: preserving structure, adding details, and fully leveraging existing state-of-the-art pre-trained super-resolution models.

The paper specifically compares different super-resolution strategies. Direct interpolation and regression-loss-trained super-resolution models tend to produce blurry outputs; diffusion-based super-resolution may accidentally alter local semantics; while GAN-based models like Real-ESRGAN achieve a better balance between clarity, stability, and speed.

Step 3: Add Minor Noise and Perform High-Resolution Refinement

The upscaled image already resembles a high-resolution output, but it still inevitably contains unclear local details or semantic inconsistencies—especially when generating text. The reason is simple: super-resolution networks do not understand prompts, and may add textures that look plausible but are semantically incorrect.

Therefore, MrFlow re-encodes the super-resolved image back to latent space, then injects a small amount of low-intensity noise to prepare for the next refinement pass. Since super-resolution does not alter the low-frequency information of the main subject, and only a small portion of the added high-frequency details require correction, typically only noise with an intensity of around 0.12 is needed to overwrite problematic high-frequency signals.

Finally, the original flow-matching model performs a single-step high-resolution refinement. Only one step is needed because the prior low-resolution generation and super-resolution already provide sufficient valid information, and the noise added to overwrite incorrect signals is very low. This naturally places the high-resolution inference starting point on the trajectory close to the clean image, allowing single-step sampling along a straight path.

Advantages Over Other Training-Free Acceleration Methods

Considering the trade-off curves and implementation details, MrFlow demonstrates significant advantages: flexible configuration, high efficiency and accuracy, and simple code. Its Geneval test metrics vs. acceleration ratio curve consistently stays in the upper-right quadrant of the plot, outperforming all other training-free acceleration methods.

Notably, cache-based methods quickly break down when the end-to-end acceleration ratio exceeds 4x.

Other multi-resolution acceleration methods perform upsampling in latent space, which easily causes blurriness, artifacts, and local structural distortion, with inconsistent generalization across different models. Visual comparisons reveal even more pronounced differences than test metrics: these methods frequently suffer from local texture collapse or structural instability at high acceleration ratios, while MrFlow preserves details much more cleanly.

Side-by-side comparisons of outputs from various methods confirm the same trend: MrFlow achieves the best speed-quality balance among training-free approaches; when combined with distillation-based methods, it can further stack additional speedups.

Comparison example on Qwen-Image:

Comparison example on FLUX.1-dev:

Compatible with All Advanced Models and Orthogonal to Timestep Distillation

The paper and open-source repository already support multiple state-of-the-art models:

Notably, MrFlow can also be stacked with timestep distillation models, achieving over 25x acceleration compared to the original 50-step baseline model. This means if you already have distilled models like Pi-Flow or Z-Image-Turbo, MrFlow can directly connect to existing weights to further increase speed without requiring a full retraining of the pipeline.

Fully Open-Sourced, Including a ComfyUI Plugin

The authors have organized a one-click runnable minimal demo and complete parameterization examples for all supported models in the GitHub repository.

Beyond standard algorithm code, they have also released a ready-to-use ComfyUI plugin example for immediate use by community creators. Implementations of MrFlow on latest models like Krea-2 already exist in the community.

Additional Discussion

The multi-resolution strategy is not entirely unprecedented: workflows like Hires.fix in the community have long introduced super-resolution in pixel space. The difference is that MrFlow does not aim to push pre-trained models to higher-resolution generation domains; instead, it focuses on accelerating generation within the model's existing capabilities, and systematically demonstrates why this pipeline works effectively.

In other words, MrFlow addresses not "whether the model can generate larger images" but rather "since the model already knows how to generate images, can we avoid unnecessary computations in high-resolution space?" Following this line of thinking—completing overall layout in low-resolution first, then filling in details in high-resolution—represents a more targeted allocation of computational resources.

More intelligently planning the granularity of computation is what makes MrFlow simple yet highly effective.

Paper Title: Multi-Resolution Flow Matching: Training-Free Diffusion Acceleration via Staged Sampling

Paper Link: https://arxiv.org/abs/2607.01642

Code Link: https://github.com/Xingyu-Zheng/MrFlow

Hugging Face Daily Paper: https://huggingface.co/papers/date/2026-07-03

Hugging Face Trending Papers: https://huggingface.co/papers/trending

This article is from the WeChat public account AI Business Review, authored by the MrFlow Team, and republished with authorization from 36Kr.