REVEL: Streaming Drag-Oriented Video Manipulation

• The paper introduces REVEL, a novel formulation that enables fine-grained, drag-oriented control for autoregressive video diffusion models during streaming generation.
• It unifies editing and animation by supporting drag operations such as translation, deformation, and 2D/3D rotation while addressing latent drift and context interference.
• DragStream, the primary method, leverages Adaptive Distribution Self-Rectification and Spatial-Frequency Selective Optimization to stabilize latent distributions and improve drag fidelity.

Searching arXiv for the primary REVEL paper and closely related work on streaming drag-based video manipulation. {"queries":[{"query":"arXiv (Zhou et al., 3 Oct 2025) Streaming Drag-Oriented Interactive Video Manipulation Drag Anything Anytime","preferred_fields":["title","abstract","authors"]},{"query":"MotionStream Real-Time Video Generation with Interactive Motion Controls arXiv (Shin et al., 3 Nov 2025)","preferred_fields":["title","abstract","authors"]},{"query":"Drag-A-Video Non-rigid Video Editing with Point-based Interaction arXiv (Teng et al., 2023)","preferred_fields":["title","abstract","authors"]},{"query":"DragVideo Interactive Drag-style Video Editing arXiv (Deng et al., 2023)","preferred_fields":["title","abstract","authors"]}]} I’m checking the returned arXiv matches and then I’ll synthesize the encyclopedia entry using the cited papers. Streaming Drag-Oriented Interactive Video Manipulation, abbreviated REVEL, is a task formulation for fine-grained control of autoregressive video diffusion models through interactive drag operations performed at arbitrary times and on arbitrary content. It was introduced to address the difficulty of enforcing continual alignment between streaming video generation and user intent in autoregressive video diffusion models, especially when edits must be applied during generation rather than specified in advance. In the REVEL formulation, drag-style manipulation is unified across both editing and animation, and supports translation, deformation, and 2D/3D rotation. The primary method proposed for resolving the task is DragStream, a training-free framework that operates inside the autoregressive sampling loop and couples latent optimization with mechanisms for distribution stabilization and context filtering (Zhou et al., 3 Oct 2025).

1. Task definition and formal scope

REVEL is defined on autoregressive video diffusion models that generate videos frame-by-frame with a context window of preceding frames. If $\Gamma_k$ denotes the $k$-th generated video frame, autoregressive generation follows the factorization

$$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$

where $L_c$ is the context length. Each conditional is realized by iteratively denoising a Gaussian latent $z^i_{T_i} \sim N(0,I)$ with a DiT-based denoiser $\epsilon_\Theta(\cdot \mid KVcache)$ while caching keys and values for temporal reuse (Zhou et al., 3 Oct 2025).

Within this setting, REVEL is defined as “Drag Anything, Anytime.” “Anything” refers to arbitrary content within generated or observed frames; “anytime” refers to the ability to intervene during streaming generation rather than only at initialization. The task unifies two previously separated modes of interaction. The first is editing, meaning direct modification of an observed frame. The second is animation, meaning forward generation of new frames from a given frame according to user-specified drag instructions. Supported drag operations are translation, deformation, and 2D/3D rotation (Zhou et al., 3 Oct 2025).

This formulation distinguishes REVEL from earlier drag-style video methods that were centered on offline editing. “DragVideo” focuses on interactive drag-style video editing with diffusion-based latent optimization, sample-specific LoRA, and Mutual Self-Attention, but it operates as an optimization-heavy editing pipeline rather than a streaming control paradigm (Deng et al., 2023). “Drag-A-Video” enables non-rigid video editing with point-based interaction on an input video and emphasizes temporal consistency through video-level motion supervision and temporal-consistent point tracking, but it is likewise organized as an offline iterative procedure (Teng et al., 2023).

2. Interaction model and drag specification

The user input for frame $k$ is written as $U_k = \{E_k, C_k\}$. Here, $E_k = \{H_k^i\}_{i=1..n}$ are binary masks defining $n$ handle regions to drag. The control set $k$0 specifies the interaction semantics. The variable $k$1 selects task type, and $k$2 specifies the drag type for handle region $k$3. A separate binary mask $k$4 specifies the non-editable region of $k$5 (Zhou et al., 3 Oct 2025).

The object-level drag parameterization differs between editing and animation, and between rotation and non-rotation operations. For animation with rotation,

$k$6

where $k$7 is the handle point, $k$8 is the rotation center, and $k$9 are target points sampled along a trajectory for subsequent frames. Otherwise, for animation,

$$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$0

For editing with rotation,

$$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$1

and otherwise

$$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$2

This yields a unified specification for both instantaneous frame editing and future-frame animation under a common drag abstraction (Zhou et al., 3 Oct 2025).

Target-region estimation is expressed through

$$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$3

where

$$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$4

The functions $$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$5 and $$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$6 implement rotation around a center and translation by an offset, respectively. Deformation is realized by translating a subset of the object mask, for example edges of the object mask (Zhou et al., 3 Oct 2025).

A common misconception is that REVEL is only a reformulation of point dragging. The formalization is broader: it includes mask-aware handle regions, non-editable regions, editing and animation modes, and multiple operation types under streaming autoregressive generation. Another misconception is that it is only about geometric editing of already observed videos. In the task definition, animation explicitly includes forward generation of new frames from a given frame (Zhou et al., 3 Oct 2025).

3. Failure modes that motivate the formulation

Two observations motivate DragStream. First, drag-induced perturbations accumulate in latent space and can cause severe latent distribution drift that halts the drag process. Let $$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$7 denote the latent embeddings for frame $$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$8 at denoising step $$P(\Gamma_{1:k}) = \prod_{i=1..k} P(\Gamma_i \mid \{\Gamma_j\}_{j=\max(i-L_c,0)..i-1}),$$9. The per-iteration latent statistics are defined as

$L_c$0

computed element-wise across latent channels and spatial positions. For a neighbor window of length $L_c$1, the neighbor averages are

$L_c$2

Distribution drift is quantified by

$L_c$3

Large $L_c$4 and $L_c$5 indicate that cumulative drag perturbations are driving the latent out of the training distribution, destabilizing generation (Zhou et al., 3 Oct 2025).

Second, context frames can interfere with streaming drag. Let $L_c$6 be the input features to DiT layer $L_c$7, and let $L_c$8 be the self-attention projections. Context mixing over cached keys and values from preceding frames yields

$L_c$9

where $z^i_{T_i} \sim N(0,I)$0 aggregates contextual cues. High-frequency components in $z^i_{T_i} \sim N(0,I)$1 are identified as a source of duplicated or distorted structures around handle points (Zhou et al., 3 Oct 2025).

These two observations locate the instability of streaming drag at two different interfaces: latent optimization can pull the current frame away from the learned latent prior, while context reuse can over-impose information from preceding frames. This dual diagnosis is central to why REVEL is not posed merely as “apply drag to a video model,” but as a streaming control problem with distributional and temporal-interference constraints (Zhou et al., 3 Oct 2025).

4. DragStream: training-free resolution of REVEL

DragStream resolves REVEL without finetuning through two components: Adaptive Distribution Self-Rectification (ADSR) and Spatial-Frequency Selective Optimization (SFSO). The optimization variable is the latent at a partial denoising step $z^i_{T_i} \sim N(0,I)$2, and the update is driven by a reconstruction-and-constraint objective (Zhou et al., 3 Oct 2025).

The latent update is

$z^i_{T_i} \sim N(0,I)$3

with

$z^i_{T_i} \sim N(0,I)$4

$z^i_{T_i} \sim N(0,I)$5

$z^i_{T_i} \sim N(0,I)$6

Here, $z^i_{T_i} \sim N(0,I)$7 concatenates multi-layer DiT features, $z^i_{T_i} \sim N(0,I)$8, and $z^i_{T_i} \sim N(0,I)$9 (Zhou et al., 3 Oct 2025).

ADSR

ADSR re-centers and re-scales the optimized latent using statistics from neighboring frames. After each latent optimization iteration,

$\epsilon_\Theta(\cdot \mid KVcache)$0

The theoretical justification given for ADSR is that, element-wise,

$\epsilon_\Theta(\cdot \mid KVcache)$1

so the updated latent is forced to match the neighbor-frame distribution, neutralizing the drift terms after each iteration (Zhou et al., 3 Oct 2025).

SFSO

SFSO mitigates context interference through two selective mechanisms.

The first is Switchable Frequency-domain Selection (SFS), which filters cached keys and values in frequency space:

$\epsilon_\Theta(\cdot \mid KVcache)$2

$\epsilon_\Theta(\cdot \mid KVcache)$3

$\epsilon_\Theta(\cdot \mid KVcache)$4

$\epsilon_\Theta(\cdot \mid KVcache)$5

The Butterworth cutoff $\epsilon_\Theta(\cdot \mid KVcache)$6 is randomly chosen at each iteration from a set $\epsilon_\Theta(\cdot \mid KVcache)$7 to keep frequency composition balanced across iterations (Zhou et al., 3 Oct 2025).

The second is Criticality-driven Spatial-domain Selection (CSS), which gates gradients with a Gaussian map centered at the handle region:

$\epsilon_\Theta(\cdot \mid KVcache)$8

with

$\epsilon_\Theta(\cdot \mid KVcache)$9

$k$0

where $k$1 is the center of the handle-region bounding box and $k$2 by default (Zhou et al., 3 Oct 2025).

The resulting pipeline is plug-in and model-agnostic for DiT-based autoregressive video diffusion models with latent-space denoising, multi-layer features, and KV caching. In the reported implementation, the base model is a Self-Forcing autoregressive video diffusion model with $k$3 denoising steps and latent optimization at $k$4. The feature extractor concatenates layers 12–15; the optimization uses $k$5 iterations per trajectory point, SFS cutoff frequencies $k$6 sampled randomly per iteration, AdamW with learning rate $k$7, and a modern GPU denoted H20 in the paper (Zhou et al., 3 Oct 2025).

5. Integration into streaming autoregressive sampling

DragStream is designed to run inside the autoregressive sampling loop. During streaming, the model samples a new latent $k$8, denoises to $k$9, and conditionally performs self-guided optimization if a user drags on frame $U_k = \{E_k, C_k\}$0. For editing, $U_k = \{E_k, C_k\}$1 and detached features from the current frame provide references. For animation, $U_k = \{E_k, C_k\}$2 and perturbed references from frame $U_k = \{E_k, C_k\}$3 guide future latents. After optimization and ADSR rectification, denoising continues from $U_k = \{E_k, C_k\}$4 to $U_k = \{E_k, C_k\}$5, the frame is rendered, and both KV caches and neighbor buffers are updated (Zhou et al., 3 Oct 2025).

Because the method uses the base model’s existing context handling, it does not redefine autoregression; instead, it inserts task-specific optimization and stabilization into a partial denoising stage. This is why the method is described as training-free rather than as a new generative backbone. The architectural hooks are limited to a feature extractor $U_k = \{E_k, C_k\}$6, a latent-region optimizer, ADSR normalization from neighbor statistics, SFS filtering on cached keys and values, CSS gradient gating, and a UI interface for constructing target mappings and masks (Zhou et al., 3 Oct 2025).

A related but distinct line of work is “MotionStream: Real-Time Video Generation with Interactive Motion Controls,” which addresses low-latency causal motion control rather than latent optimization for drag editing. MotionStream distills a bidirectional motion-controlled teacher into a causal student, introduces sliding-window causal attention with attention sinks, rolling KV caches, and self-rollout training, and supports trajectory painting, camera control, and motion transfer with sub-second latency and up to 29 FPS on a single GPU (Shin et al., 3 Nov 2025). This suggests that REVEL-like interactivity can be realized through at least two different technical routes: a training-free latent-optimization route exemplified by DragStream, and a causal-student streaming-generation route exemplified by MotionStream. The former emphasizes plug-in controllability for autoregressive video diffusion models; the latter emphasizes native real-time generation under causal attention constraints.

6. Evaluation, comparisons, and limitations

The DragStream evaluation uses 204 synthetic video clips generated and annotated using Self-Forcing to form a benchmark for REVEL, with varied scenes and drag trajectories. The baselines are the training-free methods SG-I2V and DragVideo; finetuning-heavy methods such as Tora and DragAnything are excluded to keep the comparison fair and training-free. Four metrics are reported: FVD and FID for perceptual quality, ObjMC for motion fidelity, and DAI for drag editing quality. DAI is defined as

$U_k = \{E_k, C_k\}$7

where $U_k = \{E_k, C_k\}$8 is a square of side $U_k = \{E_k, C_k\}$9 centered at $E_k = \{H_k^i\}_{i=1..n}$0 and $E_k = \{H_k^i\}_{i=1..n}$1 (Zhou et al., 3 Oct 2025).

DragStream achieves the best, meaning lowest, FVD and FID, and the highest control accuracy, meaning lowest ObjMC and DAI. The ablations are consistent with the method design. Removing SFSO significantly degrades performance, and further removing ADSR worsens it more. SFS with switchable cutoff frequencies outperforms fixed low or high $E_k = \{H_k^i\}_{i=1..n}$2. In the objective-function ablation, using $E_k = \{H_k^i\}_{i=1..n}$3 yields ObjMC 26.12, FVD 596.51, FID 25.16, and DAI 0.0545. Without $E_k = \{H_k^i\}_{i=1..n}$4, ObjMC becomes 20.87, FVD 949.06, FID 33.55, and DAI 0.0509, which is associated with worse video quality due to non-editable-region corruption. Without $E_k = \{H_k^i\}_{i=1..n}$5, ObjMC becomes 90.39, FVD 301.74, FID 14.11, and DAI 0.1337, indicating poor drag fidelity (Zhou et al., 3 Oct 2025).

The main comparisons with pre-REVEL drag-based video editing clarify the conceptual shift.

System	Primary scope	Streaming status
DragVideo	Interactive drag-style video editing	Not streaming
Drag-A-Video	Non-rigid video editing with point-based interaction	Offline iterative pipeline
DragStream for REVEL	Streaming drag-oriented manipulation in autoregressive VDMs	Streaming within autoregressive sampling
MotionStream	Real-time motion-controlled streaming video generation	Streaming causal generation

DragVideo integrates diffusion-based latent optimization, sample-specific LoRA, and Mutual Self-Attention, and reports an end-to-end time of about 5–10 minutes for a 16-frame sequence on a single RTX-4090 or RTX-A6000, indicating an offline interactive workflow rather than real-time streaming (Deng et al., 2023). Drag-A-Video similarly relies on DDIM inversion, multiple optimization iterations, and multi-frame supervision, and is explicitly characterized as an offline editing process rather than real-time streaming (Teng et al., 2023).

Several limitations remain in the REVEL setting. Extremely large-magnitude drags or heavy occlusions can stress the optimization and may require more iterations or careful handle selection. Frequent high-frequency selection, with $E_k = \{H_k^i\}_{i=1..n}$6, increases artifact risks, while excessively low $E_k = \{H_k^i\}_{i=1..n}$7 induces blurring. DragStream also relies on latent-region optimization and, by the authors’ description, may not match the absolute controllability of specialized finetuned controllers in some edge cases. In addition, true 3D rotations are approximated via sub-region translations assisted by the video diffusion prior rather than explicit 3D geometry (Zhou et al., 3 Oct 2025).

These limitations delimit the present scope of REVEL. It is a standardized streaming drag paradigm rather than a complete solution to arbitrary interactive video control. Nonetheless, by formalizing anytime drag intervention in autoregressive video diffusion models and by identifying latent drift and context interference as the central obstacles, REVEL establishes a task definition against which both training-free plug-in methods such as DragStream and causal streaming generators such as MotionStream can be compared (Zhou et al., 3 Oct 2025).