ArcFlow: Unleashing 2-Step Text-to-Image Generation via High-Precision Non-Linear Flow Distillation

TL;DR

ArcFlow is a 2-step text-to-image distillation method that replaces the linear-shortcut assumption used by prior few-step distillers with an explicit non-linear trajectory parameterization. Concretely, it parameterizes the student’s velocity field as a mixture of continuous momentum processes — a structure whose ODE admits a closed-form analytic solver, so a single forward pass yields exact (non-discretized) integration over an arbitrarily long timestep interval. Built on Qwen-Image-20B and FLUX.1-dev, ArcFlow fine-tunes <5% of parameters (rank-256 LoRA on FFN layers + output head) and achieves ~40× speedup at 2 NFEs while beating pi-Flow, TwinFlow, Qwen-Image-Lightning, and SenseFlow on Geneval / DPG-Bench / OneIG-Bench and on FID/pFID against the 50-step teacher.

Key claims

Linear-shortcut distillation (consistency models, DMD, TwinFlow, Qwen-Image-Lightning) fails to track the teacher’s tangent variation across timesteps, producing a geometric mismatch that is the dominant source of quality degradation at 2 NFEs [§1, §3].
Parameterizing the velocity field as a mixture of K continuous momentum processes gives a non-linear trajectory whose ODE has a closed-form analytic integral, so the student computes the exact target latent in one forward pass without numerical discretization error [§3.1, §3.2, Eq. (2)–(5)].
A theorem shows that with K ≥ N modes, the mixture parameterization admits a configuration that exactly fits the teacher velocity at N distinct sampled timesteps, formally justifying the choice [Theorem 1, §3.1].
The analytic Momentum Integral Coefficient smoothly reduces to the linear form as the momentum factor → 0, so the non-linear solver degrades gracefully into the linear regime — no singularity at the limit [§3.2].
A two-step distillation procedure (Mixed Latent Integration + Instantaneous Velocity Matching) with a curriculum that hands off integration from teacher to student avoids adversarial losses and full-parameter training — only rank-256 LoRA on FFN layers and the output head are trained [§3.3, Algorithm 1].
At 2 NFEs on FLUX.1-dev, ArcFlow-FLUX beats Pi-Flow (GM-FLUX), SenseFlow, and the 50-step FLUX teacher on multiple Geneval / DPG-Bench / OneIG-Bench axes, and roughly halves FID vs SenseFlow (16.83 vs 27.55) [Table 1, Table 2].
At 2 NFEs on Qwen-Image-20B, ArcFlow-Qwen reaches FID 12.40 / pFID 3.78 vs the 50-step teacher — beating TwinFlow (16.77 / 4.34) and Qwen-Image-Lightning (16.86 / 11.32), with substantially better OneIG-Bench Diversity (+85.7% over Qwen-Image-Lightning) indicating less mode collapse [Table 1, Table 2].
Convergence is faster and more stable than pi-Flow and TwinFlow on Qwen-Image-20B: ArcFlow surpasses Qwen-Image-Lightning’s FID after only ~1,000 training steps [Fig. 2, §4.2].
Ablations: learnable per-sample momentum factor β beats fixed β beats β→0 (linear); decoupling distinct basic velocities from distinct momentum factors (K_v=K_β=K) outperforms either restricted variant; mixture size K=16 is the practical sweet spot, K=32 only marginal [§4.3, Tables 3–5].

Method

ArcFlow rests on a single observation: the teacher’s PF-ODE trajectory has continuously-varying tangent directions, and approximating it with linear shortcuts forces the student to absorb that variation implicitly. ArcFlow instead parameterizes the velocity field analytically. Let v(x_t, t) be the student’s velocity. ArcFlow predicts, at each timestep, a set of K (basic velocity v_k, momentum factor β_k, gating probability π_k) tuples; the full velocity is the gated mixture v(x_t, t) = Σ_k π_k v_k · exp(-β_k (s - t)). This continuous-momentum structure means that integrating v from t to s admits a closed-form solution: each mixture component contributes v_k · (1 - exp(-β_k(s - t))) / β_k, which smoothly reduces to the linear flow update v_k · (s - t) as β_k → 0. Effectively the student computes the exact ODE solution over [t, s] in one forward pass — no Euler step, no discretization error.

Training is two-loop. The outer loop selects a timestep interval [t, s]; the inner loop alternates Mixed Latent Integration, which constructs latent targets x_{t_i} at intermediate timesteps t_i by mixing teacher-driven and student-driven sub-integrations (with the mixing ratio annealed over training so that early on the student sees teacher-manifold latents and later sees its own), and Instantaneous Velocity Matching, which minimizes the squared distance between the student’s instantaneous velocity (derived from the predicted mixture parameters via Eq. (2)) and the teacher’s velocity at the same (x_{t_i}, t_i). Only rank-256 LoRA adapters on the FFN layers plus a new output projection head for the mixture parameters are trainable; the backbone is frozen.

Results

Two backbones, both at 2 NFEs against multi-step teachers:

FLUX.1-dev (teacher: 50 steps). ArcFlow-FLUX achieves Geneval 0.65 (teacher 0.66), DPG-Bench 84.29 (teacher 84.16, so 2-step exceeds teacher on prompt alignment), FID 16.83 / pFID 11.20 (vs SenseFlow 27.55 / 9.25 and pi-Flow 32.62 / 37.84), and CLIP 0.315 (matching teacher 0.312) [Tables 1, 2].

Qwen-Image-20B (teacher: 50 steps). ArcFlow-Qwen achieves Geneval 0.85, DPG-Bench 88.46 (matching the teacher 88.32), OneIG-Bench Diversity 0.182 (vs Qwen-Image-Lightning 0.098 — a +85.7% relative gain, the headline diversity win), FID 12.40 / pFID 3.78 against the teacher (best in the comparison; TwinFlow second at 16.77 / 4.34), and CLIP 0.325 (matching teacher) [Tables 1, 2].

Speedup is reported as ~40× wall-clock against the 50-step teacher. Convergence (Fig. 2) shows ArcFlow’s FID dropping faster and more monotonically than pi-Flow and TwinFlow under matched batch size 16, with ArcFlow passing Qwen-Image-Lightning’s quality bar after ~1k training steps.

Why it’s interesting

This is the strongest filed evidence that the “linear shortcut” assumption baked into every recent distillation method (consistency models, rectified flow, DMD, VSD, TwinFlow, Qwen-Image-Lightning) is the actual quality bottleneck at 2 NFEs — not the choice of loss (adversarial vs regression) or the choice of backbone. ArcFlow’s parameterization is a structural fix: replace the linear discrete update with an analytic non-linear solver, and the student aligns with the teacher cleanly enough that LoRA-only fine-tuning (<5% of parameters) suffices. That last property is the practically interesting one for Luma — full-parameter distillation of a 20B class teacher is expensive and unstable, and ArcFlow shows that the geometric mismatch was the reason full training was “needed” in the first place. The other notable result is the +85.7% diversity gain over Qwen-Image-Lightning at matched prompt alignment, which directly addresses the mode-collapse failure mode of adversarial-objective distillers.

Contrasts with the from-scratch one-step line (SoFlow: Solution Flow Models for One-Step Generative Modeling, MeanFlow): both attack few-step inference but ArcFlow distills from a frozen pretrained teacher with adapters, where SoFlow trains the one-step map de novo. The two recipes are likely complementary — ArcFlow’s analytic momentum solver could in principle replace the implicit velocity branch in SoFlow’s Flow-Matching loss to give it a non-linear ODE backbone, though this isn’t tried in either paper.