MrFlow: climb the resolution in pixel space, not diffusion steps

2026-07-04 · 8 min · diffusion · image-generation · inference-optimization · flow-matching · explainer

A modern text-to-image model — a flow-matching or diffusion network like FLUX or Qwen-Image — makes a picture by running a stack of denoising steps. The expensive fact about that stack is where the compute lands: every step runs at the output resolution. A 20-step sample at 1024² pays the full-resolution price twenty times over, and most of those steps are spent on detail the early ones can't even see yet. That's the cost MrFlow goes after — and it does so without any fine-tuning, purely by rearranging when the model works at full size.

The idea is a budget reshuffle. Structure is decided early and is cheap to compute at small sizes; sharp high-frequency detail is what full resolution actually buys you. So MrFlow spends the pricey diffusion steps at low resolution, does the climb to full resolution in pixel space with an off-the-shelf super-resolution network, and then spends just one diffusion step at high resolution to clean up. Walk the four stages:

staged sampling · the resolution climbtraining-free · illustrative

stage

total 17u vs native 80u · ≈ 4.7×

Almost all of the diffusion FLOPs sit in step 1, run at low resolution. The resolution climb happens in pixel space for the price of one SR forward pass, and only a single high-resolution diffusion step touches the full-size image. Same 20-step budget, a fraction of the cost.

The pipeline, precisely

MrFlow is four stages, and only the outer two touch the full-resolution latent:

Low-resolution generate. Run the flow/diffusion model for ~12 of its 20 steps at a low resolution (e.g. 512²). Steps are cheap at this size, and this is where composition and layout are fixed. Decode to a low-resolution image.
Pixel-space super-resolution. Upsample that image to full resolution with a pixel-space SR network — Real-ESRGAN — in a single forward pass. This is the resolution jump, and crucially it is not more latent diffusion steps.
Low-strength noise re-injection. Encode the upscaled image back to latent and add a small amount of noise, σ_t ∈ [0.1, 0.15], computed closed-form from the flow schedule. No extra network, no training — just enough noise to give the model something to denoise.
One HR refine step. A single high-resolution diffusion step blends the upscaled detail back into the model's own distribution and cleans up the SR network's artifacts.

Pipeline comparison. Top left, 'Native' runs 50 diffusion steps at high resolution then a VAE decoder to the final image. Top right, 'Latent Upsampling' runs 20 steps, upsamples the latent, adds noise, runs 10 more steps, then decodes. Bottom, 'MrFlow' runs 12 low-resolution steps and decodes to a low-resolution image, applies an SR GAN to reach high resolution, VAE-encodes, adds a small closed-form noise σ_t·ε, runs a single refine step, and decodes to the final high-resolution image. A legend marks latent space in green and pixel space in orange. — Native runs every step at full resolution; latent-upsampling schemes climb by adding more latent diffusion steps. MrFlow instead climbs in pixel space with an SR network, then spends a single high-resolution refine step — the resolution jump costs one forward pass, not a second block of diffusion (paper, Figure 2).

The contrast with the usual "latent upsampling" trick (middle row of the figure) is the whole point. Those schemes also start small, but they climb by running more latent diffusion steps at the higher resolution — you pay full-resolution diffusion twice. MrFlow does the climb with a cheap pixel-space network and buys back fidelity with a single diffusion step.

Where the budget actually goes

The reason this is faster isn't subtle: high-resolution diffusion steps are the expensive line item, and MrFlow runs almost none of them. If you count an HR step as roughly 4× an LR step (2× the linear resolution is 4× the pixels), a native 20-step HR sample and a MrFlow (12, 1) config are worlds apart in compute. Drag the config and watch the budget — and the honest quality tradeoff — move:

the budget · (n_lr, n_hr) configcompute schematic · illustrative

config (12, 1)

17u

vs native 80u

4.7×

n_lr · low-res steps12

n_hr · refine stepsbalanced — near native on forgiving models

Speedup is the honest part: fewer, cheaper steps mean less compute, full stop. Quality is the config-dependentpart. Strip the refine steps to zero and the SR network's artifacts survive; starve the LR stage and the composition never sets. The advertised “within 1% of native” lives at the conservative end of this slider — the aggressive end is where the real degradation shows up.

That schematic is where the config dependence lives, and it's the first honest caveat. The speedup is the reliable part — fewer, cheaper steps is unambiguously less compute. Quality is the part that swings: strip the refine steps and Real-ESRGAN's artifacts survive to the final image; starve the low-resolution stage and the composition never locks in.

Why pixel-space SR instead of more diffusion

The subtle design question is: once you have a low-resolution image, how do you get to full resolution? The latent-upsampling answer is "more diffusion." MrFlow's answer is "a super-resolution network, then one diffusion step to fix it." The paper compares SR backbones — bilinear interpolation, SwinIR, OSEDiff, Real-ESRGAN — with and without the final HR refine step:

Staged super-resolution comparison. Far left, a low-resolution input crop of a shop scene with a chalkboard reading '9am'. To the right, a grid: columns are Interpolate, SwinIR, OSEDiff, and Real-ESRGAN; the top row is labelled 'SR' (super-resolution only) and the bottom row 'High Resolution Refine' (SR followed by one diffusion refine step). Zoomed insets of the '9am' text show interpolation stays blurry, and the Real-ESRGAN column with the refine step recovers the sharpest, cleanest lettering. — The SR stage on its own (top row) can leave text and edges blurry or artifact-ridden; a single high-resolution refine step (bottom row) cleans them up. Real-ESRGAN plus the refine step recovers the crispest detail — the refine step exists precisely to fix the SR network's mistakes (paper, Figure 3).

Two things read off that grid. First, the SR network alone is not enough — plain interpolation stays soft, and even a strong SR net can hallucinate wrong detail (look at the "9am" text). Second, the single refine step is doing real work: the bottom row is visibly cleaner than the top. Real-ESRGAN can introduce its own artifacts, and the HR refine step is there precisely to fix them — the two stages are a pair, not alternatives.

The speed–quality frontier

The payoff is best seen as a Pareto plot: quality against speedup, versus the obvious baseline of just running the model with fewer native steps. Toggle the model and walk the refine-step configs:

speed vs quality · the Pareto frontierGenEval · paper Fig. 5

MrFlow (+3) speedup

5.6×

GenEval

0.645

of native (0.665)

97.0%

model

refine steps

Just running the model with fewer native stepstrades quality away fast. MrFlow's frontier stays near native quality much further to the right — but this is the goodcase. Add refine steps (+3) and you buy back quality at the cost of speed; push the split harder and degradation climbs. On a less forgiving model or an aggressive config (FLUX at (12,1) drops ~18% on OneIG), the “within 1%” headline no longer holds.

Two scatter plots of GenEval score (y-axis) versus speedup ratio (x-axis), for FLUX.1-dev on the left and Qwen-Image on the right. A star marks native quality at speedup 1. A dark 'Native Steps' curve falls steeply as speedup increases. Several acceleration baselines — ToMA, TeaCache, DB-Taylor, RALU, SPEED — sit below and to the left. MrFlow's three configs (+1, +2, +3 refine steps) form a red frontier, highlighted with an ellipse, that stays high in quality much further to the right than any baseline. — Quality (GenEval) versus speedup for FLUX.1-dev and Qwen-Image. Just cutting native steps (dark curve) sheds quality fast; other accelerators sit below the frontier. MrFlow's +1/+2/+3 configs (red) hold near-native quality much further to the right — but note the frontier still bends down as speed climbs (paper, Figure 5).

The shape is the honest summary. On the good configs, MrFlow's frontier dominates both "fewer native steps" and prior accelerators like TeaCache and RALU — you get several× speedup while staying close to the native star. But the frontier still slopes downward: more speed costs some quality, and the +1 config (fastest) sits measurably below +3. Qwen-Image holds its quality far better than FLUX across the same speedups, which is exactly the point about model dependence — some base models tolerate the reshuffle much better than others.

The honest headline

The clean numbers to keep are the training-free ones: roughly 4–9× faster on the frontier configs at near-native quality, no fine-tuning required. The bigger figures you may see quoted come with strings:

A few smaller honesty notes. "Within 1%" is a best case measured on forgiving configs and models; the same pipeline pushed to (12, 1) on FLUX loses ~18% on OneIG. The compute-unit accounting in the diagrams above is a schematic (an HR step is roughly 4× an LR step) — the paper's speedups are measured wall-clock, and they depend on the SR network's own cost, which the unit count glosses over. And Real-ESRGAN, being a GAN, can invent detail that isn't in the low-resolution image; the refine step mitigates but doesn't fully erase this.

The take

MrFlow's contribution is a reframing more than a new network: the resolution climb doesn't have to be paid for in diffusion steps. Set against the usual acceleration playbooks — caching redundant computation (TeaCache-style), or simply taking fewer steps — it makes a sharper bet: structure is cheap and settles early; resolution is expensive and can be borrowed from a pixel-space SR net; artifacts are cleanable in one diffusion step. Because every piece is training-free and closed-form, it drops onto an existing checkpoint with no retraining, which is the practical reason to care. The catch is the one every honest acceleration paper carries — the best-case headline is best-case. On a forgiving model at a conservative config it really is near-free; push the config or pick a brittle model and you pay for the speed in quality. As a way to make an existing image model several times cheaper to sample without touching its weights, though, it's a clean idea, cleanly executed.

For the diffusion background this builds on, see Set Diffusion and, for how denoising models differ from autoregressive ones, the diffusion language model walkthrough.

Built on MrFlow (arXiv 2607.01642), a training-free staged-sampling accelerator for flow and diffusion image models. Benchmark and speedup figures (GenEval, OneIG; FLUX.1-dev and Qwen-Image) are quoted from the paper; the interactive diagrams are illustrations of the mechanism, and the per-stage compute units are a schematic, not measured FLOPs. Speedups are config- and model-dependent; the top-end figures require distillation on top of the training-free pipeline.