Wave Forcing: Towards Speed-of-Light Streaming Video Generation

Wave Forcing. Towards Speed-of-Light Streaming Video Generation. By Yijie Jin and nine others, from Shanghai Jiao Tong University, Xi'an Jiaotong University, and three other institutions. Published on the thirty-first of October.

Generating long video in real time means producing output continuously, with appearance that stays consistent and motion that looks natural. Existing chunk-wise autoregressive methods struggle on both speed and long-video quality. On speed, denoising is serialized, and refreshing the history cache costs a second forward pass, so even with one-step denoising each chunk needs two. On quality, longer rollouts can degrade and the camera can drift. The bottleneck is not one component but how generation, training and execution fit together.

Wave Forcing, or WF, co-designs all three, aiming at continuous video output while still using multi-step denoising. Its central property has a compact name, 1F1C: one output chunk per concurrent forward round, once the pipeline has filled. Instead of finishing one chunk before starting the next, work on several chunks proceeds at once, staggered like a wave.

Two choices make that possible on the generation side. Chunk-wise causal attention lets a chunk look at earlier, cleaner chunks before their denoising has finished. And the staggered denoising and cache-refresh stages are distributed across full replicas of the model, so they run concurrently rather than in sequence.

The model has to be adapted to generate this way, which takes a three-stage training procedure. It introduces, in order, mixed-noise denoising, motion supervision, and causal adaptation using history the model generated itself. Execution is handled by Wave Runtime, or WaveRT. It relies on Wave Parallelism, WP, for early delivery of keys and values and for overlapping communication with computation, alongside optimized kernels and pipelined VAE decoding.

Quality is tested on Wan2.1, the text-to-video model at one point three billion parameters. There, five-step WF keeps overall quality comparable to Rolling Forcing while scoring higher on Dynamic Degree, for both short and long videos.

Then the system efficiency numbers. With four denoising steps on eight H200 GPUs, WF reaches one hundred forty-seven point six DiT frames per second, and one hundred thirty-four point eight frames per second end to end. That is seven point zero seven times the single-GPU end-to-end throughput.

A separate DiT-only test isolates the parallelism itself, matching the SageAttention with W8A8 backends, the denoising steps, and the GPU counts. Set against whichever is faster of the Ulysses and Ring context-parallel baselines, WP delivers up to two point five three times the throughput, across six model scales running from one point three billion parameters to fourteen billion.

Much of the speed in this system comes from refusing to wait. Chunks start before their predecessors are clean, replicas work on different stages at once, and keys and values move early. The training recipe exists so the model can tolerate seeing history in that unfinished state, and the reported quality suggests it can.

Wave Forcing. Towards Speed-of-Light Streaming Video Generation. By Yijie Jin and nine others, from Shanghai Jiao Tong University, Xi'an Jiaotong University, and three other institutions. Published on the thirty-first of October. This is the long version: the whole paper rather than the abstract.

Streaming video generators build a long video one chunk at a time, each denoised over a few steps and conditioned on the chunks before it. Then comes a step that is easy to miss. The history that later chunks read is stored as keys and values from the attention layers, and those were computed from a noisy input. To keep a clean history, the model runs one more full forward pass over the finished chunk, called store, which keeps the keys and values and throws the prediction away. Done in sequence, four denoising steps cost five forward passes per chunk, and even one step costs two. The goal is one forward round per chunk, without dropping a single denoising step.

The idea is borrowed from wavefront scheduling. Picture a grid where columns are chunks and rows are denoising stages. In any given round, the oldest active chunk is on its last stage, the next one is a stage behind, and the newest is just leaving pure noise. These cells sit on a diagonal that moves forward each round. Give every stage, and the store step, its own full copy of the model on its own GPU, and once the pipeline fills, one chunk leaves the end every round.

The catch is that a newer chunk must condition on predecessors that are not finished yet. The paper's answer is chunk-wise causal attention. Within a chunk, attention is full. Across chunks, a chunk sees the anchor, the clean history, the live store, and every earlier, cleaner chunk in flight, but never a later, noisier one. Rolling Forcing, the method this builds on, also let chunks look the other way, at their noisier successors. Wave Forcing removes that reverse refinement.

Without retraining, removing the reverse attention lowers short-video quality and motion. So training comes in three stages, on the one point three billion parameter Wan two point one text-to-video model.

The first stage starts from Rolling Forcing's mixed-noise setup and trains with distribution matching distillation, sampling a Rolling Forcing or a Self Forcing rollout with equal probability. The second stage is off-policy. It re-noises consecutive chunks of teacher videos, made by the fourteen billion parameter Wan model, at staggered timesteps, and supervises the student with distillation plus a perceptual loss. This is where motion and framing get their guidance. The third stage is on-policy: each iteration picks a self-generated rollout from Rolling Forcing, Wave Forcing or Self Forcing, one third each, so the model learns to read its own imperfect history. Only the Wave Forcing path is deployed.

Wave Runtime handles the remaining problem: attention still waits on keys and values from other GPUs. Cleaner chunks read shorter contexts, so their replicas tend to run ahead. Each replica publishes its keys and values right after projection, at every layer, and the consumer checks readiness only at the moment it needs them. The paged variant writes them straight into their final attention slots, so nothing is concatenated on arrival. The paper proves that this asynchronous schedule produces the same latents as the synchronized one, given fixed weights, noise and context rules. Decoding is split across three GPUs, balanced from profiled timings.

On quality, five-step Wave Forcing scores eighty-one point six four on VBench Total, against eighty-one point one five for Rolling Forcing. The change is in motion. On hundred-second videos, Dynamic Degree rises from thirty-six point six three to ninety-one point four five.

The most telling comparison is Causal Forcing. On the long videos it has the highest quality score and the highest Dynamic Degree. Yet its subject disappears at thirty and seventy-five seconds, leaving pillows and a headboard in view. Benchmark scores can reward exactly that. So the authors built two diagnostics: Subject Preservation, which tracks the main subject's visibility, and Camera Drift. Causal Forcing scores seventy-one point one one and eleven point one four on them. Wave Forcing scores ninety-seven point one and zero point three seven.

The ablations show why all three training branches stay. Dropping the off-policy stage cuts Dynamic Degree from about seventy-five to under sixteen. Dropping the Rolling Forcing branch raises motion but pushes Camera Drift to six point two four. Dropping the Wave Forcing branch gives the steadiest camera and the least motion.

On speed, four-step Wave Forcing on eight H200 GPUs reaches one hundred and forty-seven point six frames per second for the diffusion model alone, and one hundred and thirty-four point eight end to end: seven point zero seven times the single-GPU baseline. Against context parallelism, Wave Parallelism wins at one point three billion parameters, at one hundred and fifty frames per second against about eighty for Ulysses. Under plain BF16, the margin shrinks as models grow, and at nine billion it trails Ulysses slightly.

The paper has a real limitations section. VBench, the authors write, does not fully characterize long-stream quality, and their own two diagnostics rest on a hundred-prompt subset, subject tracking and geometric heuristics, with agreement with human judgment not yet established. Their timings cannot isolate the decoding bottleneck. The training recipe is complex. Parallelism is capped by the step count, since each step needs its own replica, and the advantage over context parallelism narrows for larger models. High throughput, they add, does not establish low latency from input to visible output, and prompt switching or camera control were not tested at all. Beyond what they state: timings are medians of three runs, and every video uses a single seed.

The idea to carry away is that the direction of attention decides what can run in parallel. Reading only from cleaner predecessors turns a strict queue into a moving diagonal, paid for twice: in training, so the model tolerates half-finished context, and in the runtime, so keys and values arrive before they are needed. The total work never falls. What falls is the wait between chunks.