15 Forcing Methods for Faster, Longer Video Generation

Diffusion Forcing, Self Forcing, Context Forcing, Wave Forcing. Behide these terms are methods that improve video generation making it faster, longer or more accurate. But “forcing” is not one shared algorithm or one recipe. These methods change different parts of the process: how a model learns, what it remembers, and how the work of generating a video is scheduled.

Some teach a model to keep going after its own imperfect frames. Others decide which parts of the past deserve space in memory, or spread denoising across several GPUs. They can all help with faster or longer video, but they don't solve the same problem.

Here is a way to keep them apart, with a short explanation of each method and links to the papers, demos and code.

“Training” below means the method introduces a training or distillation recipe. Training-free methods modify an existing generator at inference time.

It is an earlier foundation that makes it easy to trace where some of these ideas came from. Diffusion Forcing blends sequential generation with diffusion to train the model to deal with uneven noise across tokens, letting it predict future steps while earlier ones are still a little noisy. That unlocks variable-length generation ‒ like long, smooth videos that don't fall apart past their training limit ‒ and makes it much easier to guide outputs toward a target for planning tasks.

The follow-up, Diffusion Forcing Transformer (DFoT), brings this idea to transformer-based video diffusion. It can condition on more than a fixed story ‒ on different numbers or subsets of past frames. Its History Guidance combines those different views of the past to improve consistency and motion, and help the model continue much longer videos.

An autoregressive video model trained with clean, real context frames has a slightly unfair advantage: when it starts generating, it has to continue from its own imperfect work instead. Self Forcing brings that situation into training. The model generates a sequence using its own earlier outputs, while a video-level objective evaluates the result as a whole. A few-step diffusion model, gradient truncation, and KV caching keep the process practical. This makes fast streaming generation possible, although quality can still drift when the video runs much longer than the clips used in training.

This method doesn’t finish one frame and then completely move on. It denoises several neighboring frames together, with earlier ones closer to completion and later ones still noisier. Letting those frames influence each other helps stop a small mistake from simply being passed down the line. It also keeps cached information from the first frames as a reference for the rest of the video. Training on self-generated histories prepares it for that rolling process, supporting multi-minute streams with less accumulated drift.

A teacher that only understands short clips can still help a student make a long video. Self-Forcing++ has the student generate a longer sequence, then samples short sections for the teacher to supervise. This gives the student feedback on the problems that appear later in its own generation, without needing a long-video teacher or a new long-video dataset. It extends Self Forcing toward minute-scale generation, using historical KV-cache information.

Deep Forcing changes what the model remembers, without retraining it. Its Deep Sink keeps a substantial portion of cached history as a persistent reference and adjusts the timing information attached to it. Participative Compression then checks which cached tokens recent frames actually use and removes less useful ones. The aim is to preserve enough context for a scene to stay recognizable without letting redundant or degraded history keep steering the next frames. The authors demonstrate extending a model trained on five-second clips to videos longer than a minute.

A teacher that can look at the whole video has information a streaming student will never have. Causal Forcing addresses this mismatch when initializing the fast, few-step student: it uses an autoregressive teacher that follows the same past-to-future order. After that initialization, it applies the distribution-matching stage used in Self Forcing. The change improves the starting point for fast video generation. It can therefore be combined with methods such as Rolling Forcing to extend the video length.

This method gives both the student and teacher a longer view, so supervision can account for earlier subjects and scenes. Its Slow-Fast Memory system compresses redundant visual history to keep that longer context manageable, which works better than just letting the cache grow with every new frame.

Keeps a compact running state of the older history through linear temporal attention, while block-sparse attention handles recent frames without checking every possible connection. It distills the model in stages, first with dense attention and then with the hybrid design. The result is a generator that can keep drawing on the past without keeping all of it in a growing cache.

The idea is to train one model to work at different step counts, using adversarial objectives to improve realism, keep predictions consistent across step counts, and strengthen the first frame. For longer videos, Any Forcing also chooses which historical states are still useful. That memory selection needs no additional training, though the generator itself does.

A video chunk does not have to be completely finished before it can help generate the next one. Wave Forcing lets newer chunks use earlier, cleaner chunks while those are still being denoised. It then spreads the staggered stages across several full copies of the model on different GPUs. Once the pipeline fills, it can output one chunk per concurrent forward round, without reducing the whole process to one-step denoising.

Usually, the next video chunk sees the finished result of earlier chunks. Trajectory Forcing keeps the intermediate predictions that produced them around and uses selected ones as context for what comes next. It first learns from pseudo-trajectories built from real videos, then from its own generated trajectories. To avoid attending to every intermediate state, each denoising update selects one prediction from each retained earlier chunk.

Relax Forcing gives different parts of memory different jobs: initial frames anchor the scene, recent frames keep movement continuous, and selected frames in between provide useful motion history. It chooses that middle group to stay relevant without repeating what the recent context already contains. This is an inference-time memory change, so it can improve an existing model without retraining it.

One-Forcing adds an adversarial training objective to distribution-matching distillation, giving the student model another signal for producing realistic video in that single step. It also generates autoregressively at the latent-frame level rather than in larger chunks, which makes the adversarial training more stable.

Keeping the first frames in memory can help preserve a scene, but making every attention head look at them can also hold back movement. Disen-Forcing separates those jobs during distillation: a small set of heads handles long-range semantic anchoring, while the others focus on local motion. It changes how context reaches those heads and adds a training constraint to keep the two roles distinct, aiming for consistency without turning the video into a nearly still image.

Causal Forcing++ pushes the same idea toward generating one frame at a time in just one or two sampling steps. It replaces the original initialization procedure with causal consistency distillation, which learns from a single teacher step at a time instead of requiring a large precomputed collection of complete denoising trajectories. That reduces the work needed to prepare the student and makes the more aggressive few-step setup practical. In the authors’ comparison, the two-step frame-wise model halves first-frame latency relative to their four-step chunk-wise baseline.

It is a label used by several research methods, not one standard algorithm. Some change the training setup, others manage past context or schedule denoising. The shared name does not mean they are interchangeable.

Diffusion Forcing trains a sequence model with different noise levels across tokens. Self Forcing trains an autoregressive video model on its own generated history, so it learns to continue from the imperfect context it will encounter at inference.

No. Many introduce a training or distillation recipe, but some change inference instead. Deep Forcing, for example, manages the KV cache without additional training.

Not necessarily. Throughput measures how much video a system produces over time; latency measures how long you wait for a result. A pipeline can raise throughput after it fills while still taking time to produce its first chunk. Always check GPU count, resolution, denoising steps and what timing the paper reports.

Being able to keep generating is not the same as keeping a scene coherent indefinitely. Errors can accumulate, and a fixed memory budget may discard useful details. Check how long the authors actually evaluate, rather than treating long-video or infinite-video generation as a guarantee.