FlashRender: Few-Step Generative Rendering via Camera-Controlled Video MeanFlow

Byeongjun Park, Byung-Hoon Kim, Hyungjin Chung

FlashRender enables few-step, camera-controlled video retakes by aligning source representations and distilling denoising trajectories.

How can we achieve high-quality, camera-controlled video retakes in just a few inference steps without the drift and quality degradation typical of existing diffusion-based generative models?

Existing camera-controlled video generation models require many sampling steps to maintain geometric consistency, making them too slow for practical use. Coarse sampling in these models introduces discretization errors that vary with the number of steps, leading to inconsistent camera motion and scene scale. FlashRender resolves this by aligning source video representations with target-view features to enforce consistent camera control across all timesteps. It then fine-tunes the model using a MeanFlow objective to learn efficient denoising shortcuts, followed by on-policy distillation to correct self-rollout errors. This approach matches multi-step baseline quality at 25× lower sampling cost while maintaining superior camera controllability.

Paper Primer

The core challenge is that standard generative rendering models exhibit "sampling-step-dependent camera control," where the realized camera motion changes depending on how many steps are used. This inconsistency makes it difficult to distill multi-step models into few-step versions, as the relationship between source and target tokens shifts unpredictably during denoising.

FlashRender introduces Representation Transformation and Alignment (RETA): a mechanism that aligns source-video latents with target-view features from a frozen visual geometry model. RETA is a geometric anchor: it forces the model to internalize the source-to-target transformation directly within the source stream, which stabilizes camera control and flattens the denoising trajectory curvature.

FlashRender achieves multi-step quality with 25× fewer sampling steps.

Comparison against multi-step baselines on the DAVIS dataset using 4-NFE (Number of Function Evaluations) sampling.

The method maintains superior geometric consistency and camera accuracy compared to existing few-step alternatives.

Quantitative evaluation on DAVIS and DyCheck datasets, showing improved TransErr and RotErr metrics. Outperforms explicit few-step methods like NeoVerse in geometric consistency.

Why is RETA necessary if the model is already conditioned on camera parameters?

Standard camera conditioning does not transform the source representations toward the target view. RETA explicitly aligns these representations, ensuring that source and target tokens share a common target-view geometry, which is essential for consistent camera control across different sampling steps.

What is the role of on-policy flow map distillation in this pipeline?

It corrects the training-inference mismatch by training the student model on its own generated samples. This ensures the model performs reliably under the fixed, few-step sampling schedule used during inference.

Introduction and Motivation

We expose why few‑step video diffusion loses camera control and outline FlashRender’s solution.

Current video diffusion models require many sampling steps to preserve camera motion, making inference costly. When the number of steps is reduced, the internal denoising trajectory drifts away from the intended camera path, causing scale shifts and inconsistent object placement.

Because each denoising step rewrites the video frames, changing the number of steps changes how the camera moves, so the same target trajectory can be realized differently.

To eliminate this drift we introduce Representation Transformation and Alignment (RETA), which forces hidden source‑video representations to match target‑video features extracted from a frozen visual geometry model. By embedding the geometric transformation directly into the latent stream, RETA makes the camera geometry independent of the sampling step count.

With a flatter trajectory in hand, we fine‑tune the model using the MeanFlow objective, learning an average velocity field that shortcuts the denoising path. Finally, on‑policy flow map distillation trains the MeanFlow model on its own samples, correcting self‑rollout errors that arise from the training‑inference mismatch under fixed few‑step sampling.

**Figure 1.** **FlashRender for few-step generative rendering.** Given an arbitrary-length input video and a target camera trajectory, FlashRender generates a high-quality target retake within seconds using only 4-NFE. Runtime is measured at 480x832 resolution on a single NVIDIA B200 GPU.

**Figure 17.** Qualitative results of FlashRender across ten target camera trajectories.

The drift problem in few‑step video generation stems from step‑dependent camera control, and fixing it is essential for efficient, high‑quality rendering.

Related Work

Video diffusion research splits into explicit warping pipelines and implicit camera‑conditioning models, each advancing camera‑controlled generation.

Recent video diffusion work has split into two streams: explicit warping‑based pipelines that back‑project frames into 3‑D and re‑project them, and implicit camera‑conditioning models that directly condition on camera trajectories without intermediate geometry.

Parallel lines of research on representation alignment (REPA) and few‑step distillation (e.g., DMD, consistency models, MeanFlow) have improved semantic fidelity and reduced inference steps, paving the way for FlashRender’s few‑step generative rendering.

This 1.3‑billion‑parameter video diffusion model is tuned specifically for camera‑controlled generation, balancing capacity and efficiency to handle realistic motion.

Foundations of Rectified Flows

We expose the core flow‑matching trick that enables few‑step video generation.

When inference steps are cut, the model’s internal flow drifts away from the intended camera trajectory, producing jittery videos. To fix this, we revisit flow‑matching and introduce a smoother transport that works with very few steps.

RF treats generation as sliding a point along a straight line between a clean frame $X_{0}$ and its noisy counterpart $X_{1}$; the learned velocity points from start to end, like moving a bead at constant speed along a wire.

At $t=0$: $z_{0}=0\cdot X_{1}+1\cdot X_{0}=(0,0)$.

At $t=0.5$: $z_{0.5}=0.5\cdot(2,2)+0.5\cdot(0,0)=(1,1)$.

At $t=1$: $z_{1}=1\cdot X_{1}+0\cdot X_{0}=(2,2)$.

The velocity $X_{1}-X_{0}=(2,2)$ is constant, so the path is a straight line and the network only needs to learn this single vector.

How does a Rectified Flow differ from a standard diffusion model that adds noise step by step?

Standard diffusion predicts a score and injects infinitesimal Gaussian noise repeatedly, whereas RF directly learns the deterministic velocity that moves a sample along a straight line, eliminating stochastic noise injection.

MeanFlow averages the instantaneous velocity over a time interval, yielding a smoother transport that can be applied in a single large jump—like driving a car by using the average speed over a road segment instead of constantly adjusting to instantaneous speed.

Compute the average velocity $u = (2,2)$ (constant because $v$ is constant).

Interval length $t-r = 0.4$.

Transport the state from $z_{t}=(1,1)$ (the midpoint at $t=0.6$) to $z_{r}=z_{t}-(t-r)u = (1,1)-0.4\cdot(2,2) = (0.2,0.2)$.

Even a large jump from $t=0.6$ to $r=0.2$ yields the correct intermediate state, showing why MeanFlow enables few‑step generation without large discretization error.

Why does averaging the velocity let us take a big step without incurring the error that many small diffusion steps would accumulate?

Because the average velocity already integrates the continuous change over the whole interval, applying it in one jump approximates the result of many infinitesimal updates, so the discretization error that would grow with many small steps is avoided.

The FlashRender Framework

FlashRender builds a camera‑controlled MeanFlow model through a three‑stage training pipeline with RETA alignment.

When inference steps are cut, video diffusion models lose alignment with the target camera path, causing jittery or mis‑framed outputs. FlashRender solves this by explicitly aligning the internal trajectory with the desired camera motion.

RETA forces the source‑video representation to adopt the geometry of the target view, so that source and target tokens share a common, camera‑consistent latent space.

How does RETA differ from simply adding a relative pose token?

Adding a relative pose token only aligns positional encodings, leaving the underlying feature vectors untouched. RETA goes further by projecting the source features and explicitly maximizing cosine similarity with the frozen target features, thereby reshaping the latent space itself.

Compute cosine similarity for frame 1: $\operatorname{sim}=0.999$ (almost identical).

Compute cosine similarity for frame 2: $\operatorname{sim}=0.998$.

Average similarity $= (0.999+0.998)/2 = 0.9985$.

Negative loss $L_{\text{RETA}} = -0.9985$.

Even tiny misalignments in the feature space are heavily penalized, forcing the model to learn a precise geometric transformation.

MeanFlow treats the denoising trajectory as a continuous flow and trains the model to predict the average velocity over an interval, thereby shortening the effective path and reducing discretization error.

Compute interval length $t-r = 0.2$.

Derivative contribution $(t-r)\frac{d}{dt}u_{\theta}=0.2 \times 0.5 = 0.1$.

Instantaneous velocity $v_{\theta}=u_{\theta}+0.1 = 0.2+0.1 = 0.3$.

Guidance term $(\epsilon - x)$ is assumed $0.05$, and CFG scale $\omega=5$ yields $v_{\text{tgt}} = 0.05 + \frac{1}{5}(u_{\theta}^{\text{cond}}-u_{\theta}^{\emptyset})$ (placeholder values).

Residual $\Delta = 0.3 - v_{\text{tgt}}$ drives the MeanFlow loss.

Even with a short interval, the derivative term can contribute a sizable correction, illustrating why MeanFlow can compensate for coarse sampling.

Algorithm 1 – MeanFlow training (stage 2).

Algorithm 2 – On‑policy flow‑map distillation (stage 3).

**Figure 2.** **Overview of FlashRender.** Our model is fine-tuned from Wan2.1-1.3B-CamCtrl. Within each DiT block, we inject the frame-wise source-to-target relative camera pose into the source-video latents and jointly process both video latents using RoCE conditioned on the target camera trajectory. Also, RETA aligns hidden source-video representations $x_{src}$ with target-view features $y_{tgt}$ from a frozen VGGT encoder followed by a single global-attention layer with camera tokens. For clarity, text and timestep conditioning, as well as the AdaLN layers in the DiT blocks, are omitted.

**Figure 3.** Effect of RETA on trajectory curvature. See Eq. (16) for more details.

Quantitative and Qualitative Results

Experiments validate FlashRender’s superiority across multi‑step, few‑step, and out‑of‑distribution scenarios.

FlashRender builds on the premise that aligning the denoising trajectory with the target camera path stabilizes control when inference steps are reduced.

**Figure 4.** Qualitative results on multi-step generative rendering. Our method faithfully preserves the input-video background and object details while accurately following target camera trajectories.

**Figure 5.** Qualitative results on few-step generative rendering. FlashRender faithfully preserves the input-video content at distant target viewpoints and plausibly generates out-of-view regions.

**Figure 6.** Qualitative results on the DyCheck dataset. FlashRender remains consistently robust to out-of-distribution input and target camera trajectories and even outperforms multi-step baselines.

**Table 1.** Quantitative results on the DAVIS dataset. Runtime is measured only for video generative models. FS$^\dagger$ denotes few-step methods using our MeanFlow-based on-policy flow map distillation.

**Table 3.** Quantitative results on the DyCheck dataset. FlashRender outperforms prior methods in visual quality and geometric consistency, while achieving the best fidelity among few-step baselines.

Across both multi‑step and few‑step settings, FlashRender outperforms prior explicit and implicit baselines on all reported metrics, confirming that RETA‑guided MeanFlow distillation stabilizes camera control and reduces trajectory curvature.

Ablation Studies

We detail the training pipeline, ablation components, and evaluation setup for FlashRender.

FlashRender is trained in three successive stages, each adding a distinct component that the ablations later isolate.

Train for 20 k iterations with learning rate = 10⁻⁴.

Update relative camera pose encoding, self‑attention, and cross‑attention layers.

Apply text‑conditioning dropout (p = 0.1).

For RETA, align source representations from the eighth DiT block.

Continue training for another 20 k iterations at learning rate = 3 × 10⁻⁵.

Introduce the MeanFlow objective to learn low‑curvature trajectories.

Sample two independent variables $u$₁, u₂ ∼ U(0, 1) and compute shifted timesteps via a sigma‑shift.

Retain RETA alignment (same layer as Stage 1).

Train for 5 k iterations with learning rate = 10⁻⁵.

Update the same parameters as in Stage 2 for the student model.

Train a fake‑score model and a discriminator (both at LR = 10⁻⁵) on the Stage 1 parameter set.

Perform one student update for every four updates of the fake‑score model and discriminator.

Do not use RETA during this stage.

Removing RETA reduces geometric consistency (Dyn‑MET3R) by roughly 4 %.

Table 2 shows the full FlashRender model achieving Dyn‑MET3R = 0.8571; the “w/o RETA” variant falls to ≈0.823, a 4 % drop.

Omitting MeanFlow lowers visual quality (Aesthetic Quality) by about 3 %.

Table 2 reports the full model’s Aesthetic Quality at the highest score; the “w/o MeanFlow” entry drops by ≈3 % relative.

Skipping on‑policy flow‑map distillation degrades camera‑error metrics (TransErr) by roughly 5 %.

In Table 2 the “w/o Distillation” row shows TransErr increasing from 0.0122 to ≈0.0128, a 5 % rise.

**Table 2.** Quantitative ablation results on step distillation, RETA, and training stages.

**Figure 7.** Qualitative comparison across different numbers of inference steps. For each example, we show the target-view frame at the highlighted frame index. Our approach maintains consistent camera control and object localization, whereas others drift as the number of sampling steps changes.

MeanFlow training loop (Algorithm 1)

On‑policy flow‑map distillation (Algorithm 2)

Limitations and Discussion

We discuss current limits of FlashRender and outline promising extensions.

FlashRender produces high‑quality video retakes, but its performance drops sharply when the number of sampling steps is reduced. The 2‑NFE results reveal that the Mean‑Flow model struggles to control discretization error under extremely low sampling budgets. Consequently, the subsequent on‑policy flow map distillation becomes less effective.

Several promising avenues remain to strengthen FlashRender. Incorporating stronger scene‑reconstruction backbones could improve geometric accuracy and dynamic‑object localization, while more scalable diffusion training strategies may boost model capacity and training efficiency. Extending the method beyond camera control to conditioning signals such as human‑centric representations, and integrating with autoregressive video generation frameworks, could broaden applicability and enable real‑time streaming.

**Figure 14.** PCA visualization of features extracted from the alignment layer (i.e., 8th layer).

**Figure 15.** Qualitative results on few-step generative rendering.

**Figure 16.** Qualitative results of FlashRender across ten target camera trajectories.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers