AI's image drawing capability is getting stronger, but the user experience is still one word: slow.
A 1024-resolution image, from prompt to final output, diffusion models often have to sample repeatedly in high-resolution space. Quality goes up, but waiting time goes up as well. The stronger the capability, the thicker the inference bill.
Among mainstream acceleration methods for diffusion models, quantization and efficient Attention methods strongly depend on hardware co-optimization; step distillation relies on high-cost fine-tuning and is often unstable during training; feature caching methods require dynamic identification and caching of intermediate features, with an acceleration ratio difficult to exceed 5x.
Is it possible to directly boost image generation speed without relying on specific hardware, without distilling/fine-tuning the model, and without needing dynamic identification at runtime?
A research team from Beihang University, NTU, and ETH recently made a very concise attempt:
First draft at low resolution, then upscale, finally refine at high resolution.
MrFlow (Multi-Resolution Flow Matching) uses such a three-stage process to compress end-to-end generation time from 49.32s to 4.77s on models like Qwen-Image, achieving an actual speedup of 10.35x.
The paper was featured on Hugging Face Daily Papers on the day of publication; within three days of release, the GitHub repo gained over 200 stars; it has also now been featured on Hugging Face Trending Papers.
Meanwhile, community creators have already started experimenting, discussing, and extending around MrFlow:
Returning to MrFlow itself, why can such a simple process bring about a 10x magnitude of end-to-end acceleration?
First, look at the source of acceleration
MrFlow's default strong acceleration configuration is 12+1:
- 12 steps in the low-resolution stage
- Only 1 inference step in the high-resolution stage
In native high-definition generation, the heaviest computations are concentrated on high-resolution sampling. MrFlow moves the bulk to the low-resolution stage, with high-resolution only doing a short-distance refinement for details. The overhead of intermediate steps like VAE, super-resolution, and noise preparation is not significant. Even when factored into the total time, it still achieves over 10x end-to-end acceleration.
Next, look at the generation quality
Under 10x magnitude acceleration, MrFlow can stably generate clear and clean images. Quantitative metrics show the gap can be controlled within about 1%.
Samples on Qwen-Image (10.3x acceleration):
Samples on FLUX.1-dev (8.25x acceleration):
Why use multi-resolution levels?
Analyzing the design rationale: The spatial information structure inherent in images provides the condition for a naive yet highly efficient generation method like resolution reduction. Who is the subject, where is the location, what is the pose, is the composition reasonable, does the overall semantics match the prompt—these things don't necessarily have to be computed from scratch directly in high-resolution space. Lower resolution hardly severely destroys original semantic information, can maintain the overall spatial structure, and simultaneously reduces the number of image tokens quadratically.
MrFlow seizes this opportunity: first, generate the structure cheaply, and finally refine the details. The connection between the two can be directly bridged by a pre-trained super-resolution model.
Details of each step
Step 1: Low-resolution structure generation
First, let the original model generate an image in low-resolution latent space. This step is responsible for global structure: subject, layout, semantics, color ambiance.
The benefits of low resolution are straightforward:
- Quadratic reduction in image tokens, making each step cheaper.
- Low-frequency structure is easier to converge, so total steps can also be fewer.
Step 2: Return to pixel space for super-resolution
Next, decode the low-resolution result into an image, then perform super-resolution to increase the resolution.
Here's a key choice: not directly upsampling in latent space, but upsampling in pixel space.
Because although upsampling in latent space may seem convenient, it can easily lead to problems in subsequent processing like local blurring, texture confusion, and structural breakdown. Super-resolution in pixel space is more like further processing along an already determined composition: structure preserved, details added, and it can fully reuse advanced pre-trained super-resolution models.
The paper specifically compares different super-resolution strategies. Direct interpolation and some regression-loss trained super-resolution models tend to blur, diffusion-based super-resolution may incorrectly modify local semantics, while GAN-based super-resolution models like Real-ESRGAN offer a better balance between clarity, stability, and speed.
Step 3: Add a little noise, then high-definition refinement
The image after super-resolution already resembles a high-definition picture, but inevitably still has unclear local details or semantic confusion, especially regarding text generation. The reason is simple: the super-resolution network doesn't understand the prompt and may fill in textures that look reasonable but are not semantically entirely correct.
Thus, MrFlow re-encodes the super-resolved image back into latent space and then injects a small amount of low-intensity noise to prepare for the next rewriting step. Since super-resolution did not change the low-frequency information of the subject and only a small portion of the supplemented high-frequency information needs further refinement, typically only a noise intensity of about 0.12 is added here for high-frequency signal overwriting.
Finally, it's handed over to the original flow-matching model for single-step high-resolution refinement. Only one step is needed because the effective information from the previous low-resolution generation + super-resolution is already sufficient. The added noise intensity for overwriting erroneous signals is very low, so the starting point for high-resolution inference naturally falls on the trajectory closer to the clean image side. Sampling a single step along the straight-line direction suffices.
Compared to other training-free acceleration methods, what are the advantages?
Considering the trade-off curves and method implementation, MrFlow's advantages are significant: flexible configuration, efficient and accurate, simple code. The Geneval test metrics vs. speedup ratio curve remains firmly in the upper right corner of the graph, stably outperforming other types of training-free acceleration methods.
Among them, at end-to-end speedup ratios above 4x, Cache-based methods quickly face collapse.
Other multi-resolution acceleration methods perform upsampling in latent space, which can easily lead to blurring, artifacts, local structural distortion, and exhibit significant variability in generalization across different models. Visually, the differences between these methods and MrFlow are more pronounced than the test metrics: these methods often suffer from local texture collapse or structural instability at high speedup ratios, while MrFlow retains cleaner details.
When images from various methods are compared side by side, the same trend is visible: MrFlow achieves the best speed-quality balance among training-free methods; combined with distillation methods, acceleration can be further stacked.
Comparison example on Qwen-Image:
Comparison example on FLUX.1-dev:
Applicable to all advanced models, and can be orthogonally combined with timestep distillation
The paper and open-source repository already cover various advanced models:
Notably, it can also be stacked with timestep distillation models, achieving over 25x acceleration compared to the original 50-step base model. This means if you already have distillation models like Pi-Flow, Z-Image-Turbo, MrFlow doesn't need to retrain a combined solution; it can be directly applied on top of the existing weights for further speedup.
Fully open-source, including ComfyUI plugin
The authors have prepared a minimal demo for one-click execution and full parameterized examples for each model in the GitHub repository.
Beyond the regular algorithm code, they also directly provided a ComfyUI plugin example, allowing community creators to use it immediately. Currently, community implementations of MrFlow on the latest models like Krea-2 already exist.
Additional Discussion
The multi-resolution strategy actually has traces in past work: community workflows like Hires.fix also introduced super-resolution in pixel space. The difference is that MrFlow is not aiming to push pre-trained models to higher resolution drawing domains, but focuses on accelerating generation within their trained capability range, using systematic experiments to dissect why its pipeline is effective.
In other words, MrFlow discusses not "can we draw larger images?" but rather "since the model already knows how to draw, can we reduce unnecessary computations in high-resolution space?" Following this question, completing the overall layout in the low-resolution stage first and then supplementing details in the high-resolution stage is a more targeted way of allocating computational resources.
More rationally planning the granularity of computation—this is why MrFlow is simple yet 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 "QbitAI", author: MrFlow Team
