OneReel: Efficient Multi-Scene Video Generation with Scene-Structured Attention

O NE R EEL : E FFICIENT M ULTI -S CENE V IDEO G ENERATION WITH S CENE -S TRUCTURED ATTENTION

arXiv:2611.10594v1 [cs.DC] 7 Nov 2026

Wei Zhang * 1 Yuchen Wang * 1 Tianrui Feng 2 Hongrui Wu 3 Chenfeng Xu 2 Fan Lai 1

A BSTRACT Multi-scene video generation must follow scene-specific prompts while preserving consistency across scenes. Dense joint generation enables cross-scene information exchange but incurs quadratic attention cost, whereas separate generation avoids this cost at the expense of cross-scene consistency. We present OneReel, a training-free system that exploits scene structure to enable efficient multi-scene generation. Our key insight is that multi-scene generation can preserve complete intra-scene attention while restricting cross-scene information exchange to a bounded shared memory. OneReel uses scene prompts and durations to establish scene-specific attention scopes and dynamically selects a bounded set of representative latent frames for cross-scene sharing. This reduces video attention complexity from quadratic to linear in the number of scenes. To translate these savings into execution speedups, OneReel packs scene-local and shared K/V into dense variable-length attention and employs work-balanced multi-GPU partitioning with communication-aware selection between K/V gathering and Ulysses-style parallelism. Our evaluations across four video generation models show that OneReel achieves 1.7–4.9× end-to-end speedup over dense attention and 1.2–2.2× over existing sparse-attention advances, while improving text-following accuracy by 34–37 percentage points and maintaining cross-scene consistency. 1

I NTRODUCTION

Recent advances in video generation models, such as Wan3.0 (Alibaba Cloud, 2026), CogVideoX (Yang et al., 2024), and MiniMax H3 (MiniMax, 2026), are enabling increasingly complex long-form media synthesis and filmmaking (Gao et al., 2025). These applications require more than generating longer clips: users need to control individual scenes (shots), while maintaining consistency across them. In multi-scene generation, a request specifies a sequence of scene prompts and durations (Wang et al., 2026). The number and durations of the scenes define the scene structure. The generated video should follow this structure while achieving both scene-specific text-following accuracy and cross-scene consistency. Existing models can generate multi-scene videos in two ways, but neither simultaneously provides efficient generation and effective cross-scene coordination. Separate generation independently generates each scene from its own prompt and concatenates the resulting clips (Zhang et al., 2025c). Although shared images or conditioning on the preceding scene can help maintain cross-scene con*

Equal contribution 1 University of Illinois Urbana-Champaign, Urbana, IL, USA 2 University of Texas at Austin, Austin, TX, USA 3 Stanford University, Stanford, CA, USA. Correspondence to: Wei Zhang <zhangw2@illinois.edu>, Fan Lai <fanlai@illinois.edu>. Preprint.

sistency (Wan et al., 2025; Zhou et al., 2024), it requires additional generation passes or training. In contrast, joint generation denoises all scenes as a single sequence, allowing information to propagate across scenes through global attention (Meng et al., 2025). However, this unrestricted interaction incurs quadratic attention cost in the total video length and does not distinguish scene-specific content from information that should be shared. Sparse attention can reduce this computational cost, but does not fully exploit the structure of multi-scene generation. Existing training-free methods select attention scopes through online profiling or attention scores (Xi et al., 2025; Yang et al., 2026; Xia et al., 2025), or use predefined spatialtemporal patterns (Li et al., 2026d; Zhang et al., 2025d). To preserve generation quality, many of these methods retain dense attention during the initial denoising steps and enable sparse execution only afterwards, yet early dense steps already account for 20–53% of total denoising time (§2.2). Our key insight is that multi-scene generation can separate complete scene-local attention from bounded cross-scene information exchange. Scene prompts and durations provide a structural prior before denoising begins, which imply which video tokens belong to each scene and which text description should condition them. This motivates scene-structured sparsity: retain intra-scene attention for scene-specific content, and share only a small amount of information across scenes for consistency. As such, each scene attends to all

S2: hails a taxi

S3: runs in airport

S4: plane window

S5: walks on beach

S6: sunset on balcony

Joint (dense)

Separate different person

different person

OneReel (ours)

different person

2.2× faster

Identity consistency →

S1: packs suitcase

1.0

OneReel

Joint +0.27 vs Separate

0.5

Separate

0.0 50

100

200

500

Latency (s) ← faster

Figure 1: OneReel uses scene-structured attention to generate multi-scene videos faster than dense joint generation while achieving higher cross-scene identity consistency than separate generation. of its own tokens and to a limited set of tokens from other scenes, thus removing unnecessary cross-scene interactions. However, turning scene-structured attention scopes into fast, consistent generation raises unique challenges. First, how can cross-scene information sharing remain both effective and scalable? Even restricting sharing to scene boundaries incurs quadratic attention cost as the number of scenes grows, since every scene accesses information from all others. Bounding the shared context reduces this cost but risks losing information needed for cross-scene consistency. The challenge is to maintain a compact, informative memory as scene count increases and video representations evolve throughout denoising. Second, how can structured sparsity translate into efficient GPU execution? Each scene combines dense local attention with a small set of foreign information (e.g., K/V) scattered across the video sequence. Executing these irregular scopes with sparse kernels can introduce substantial overhead. Third, how can multi-GPU execution balance computation without excessive communication? Scenes have different lengths and attention scopes, so equal-sized query partitions need not have equal computational costs. Distributing every scene across GPUs can balance attention work but requires remote K/V exchange even for intra-scene attention. We introduce OneReel, a training-free runtime that translates scene structure into efficient attention computation and multi-GPU execution. It addresses these challenges through three mechanisms. (1) Scene-structured attention with bounded frame memory. OneReel assigns each scene complete local video attention and its own text conditioning. For cross-scene information exchange, it clusters pooled latentframe representations across the video and selects a bounded set of representative frames. Each scene attends to its complete local context and selected foreign frames, preserving local detail while bounding cross-scene attention work (§3). (2) Dense execution of structured attention. Rather than directly executing irregular sparse attention masks, OneReel copies the bounded foreign K/V next to each scene’s local K/V. This converts the retained attention interactions into contiguous, variable-length dense scopes. By replicating

only the shared context, OneReel trades limited data movement for substantially higher kernel efficiency (§4.1). (3) Work-balanced multi-GPU execution. OneReel partitions queries according to their attention workloads while preserving complete scenes whenever possible, thus reducing inter-GPU communication. A request-level communication cost model then selects between locality-aware K/V gathering and Ulysses-style parallelism (Fang & Zhao, 2024), accounting for the aggregate communication requirements of the resulting GPU placement (§4.2). We implement OneReel atop xDiT (Fang et al., 2024) and evaluate it on Wan2.2 (Wan et al., 2025), HunyuanVideo (Kong et al., 2024), MiniMax H3 (MiniMax, 2026) and CogVideoX1.5 (Yang et al., 2024). Across workloads with varying scene structures, OneReel achieves end-to-end speedups of 1.7–4.9× over dense attention and 1.2–2.2× over existing sparse-attention advances. It further improves text-following accuracy by 34–37 percentage points while maintaining cross-scene consistency (§5). Overall, this paper makes the following contributions: • We identify scene structure as a training-free prior for decomposing multi-scene attention into local computation and bounded cross-scene exchange (§2–§3). • We introduce novel mechanisms to enable scenestructured attention for diverse model architectures, bounded frame memory, efficient dense scope packing, and locality-aware multi-GPU execution (§4). • We demonstrate OneReel’s substantial end-to-end speedup while improving generation quality (§5).

2

BACKGROUND AND M OTIVATION

2.1

The Cost–Consistency Trade-off in Multi-Scene Generation

A multi-scene request can be served by an existing video diffusion model in two training-free ways (Fig. 1): (i) Joint generation denoises all scenes as one sequence conditioned on the request’s scene prompts, allowing scenes to exchange

cross-scene attn. 3 Hunyuan 12

intra-scene attn. 46% 82%

3

CogVideoX 12

38% 77%

3

32%

MiniMax H3 12

65%

3

19%

Wan 12

Joint generation spends most of its time on cross-scene attention. Let a video contain L video tokens partitioned into P K scenes, where scene i contains ni = ρi L2 tokens and i ρi = 1. Dense video attention computes L query–key P interactions, while intra-scene attention covers i (ρi L)2 P query–key pairs. The remaining L2 − i (ρi L)2 pairs connect different scenes. With K equally sized scenes, crossscene pairs account for 1 − 1/K of all video attention pairs, regardless of what the scenes actually share.

0

Attention mass (%)

information through attention at every denoising step; and (ii) Separate generation denoises each scene with its own prompt and concatenates the results. These two modes differ in both execution cost and their ability to combine scene-specific content with cross-scene consistency.

60%

50

100

100

90% Hunyuan Wan MiniMax H3 first step last step

80 60 40 0

Share of joint latency (%)

23%

44%

25

50

75

Key blocks kept (%)

Figure 2: Joint generation Figure 3: Early attention is spends most of its time on too diffuse for a small sparse budget. cross-scene attention. Table 1: Sparse attention spends 20–53% of denoising time in dense warm-up. Warm-up steps

Warm-up timea

5 / 50 5 / 50 10 / 50 12 / 50 15 / 50

22.2% 20.3% 43.0% 44.2% 52.9%

This computational growth translates into substantial execution overhead. Fig. 2 compares joint and separate generation at a fixed duration per scene. Across four models, the excess attention time of joint generation accounts for 19–46% of its total latency with three scenes, rising to 60– 82% with twelve. Real-world videos can contain tens of scenes (Ghermi et al., 2026), further increasing the cost of dense cross-scene attention.

Method

Separate generation avoids this global cost but loses consistency. Removing cross-scene attention lets each scene be generated in isolation, conditioned only on its own prompt. This provides no exchange of video representations across scenes, and recurring characters are re-imagined in every scene. In Fig. 1 (left), the traveler changes identity across separately generated scenes. Across the benchmark prompts (right), the share of scene pairs that DINOv2 judges to show the same subject falls from 0.87 for joint generation to 0.54 for separate generation. Joint generation keeps identities stable, but its scenes often blend into one another and drift from their own prompts, so it is not a quality ceiling either.

able, applying it throughout denoising can affect generation quality. A common practice is to retain dense attention during the initial steps and enable sparse execution only afterwards. Using their evaluated configurations, we notice that this dense warm-up occupies the first 10–30% of denoising steps but accounts for 20–53% of denoising time (Tab. 1). Fig. 3 further illustrates this challenge. We partition the attention matrix into fixed-size blocks, each covering a group of query–key interactions. During early denoising, attention mass is broadly distributed across these blocks, so even retaining the highest-scoring blocks requires a large fraction of them. Moreover, this diffuse distribution persists across denoising steps, making aggressive early sparsification prone to discarding substantial attention mass and degrading generation quality. So, early denoising provides little concentration for score-based sparsification to exploit.

These results highlight two distinct requirements. Each scene must preserve its own prompt-specific content, yet scenes that share visual elements need a means of exchanging information. Subject similarity alone does not establish that both requirements have been satisfied. Therefore, the systems challenge is not simply to eliminate cross-scene attention, but to retain useful information exchange without paying the cost of unrestricted global interactions. 2.2

Scene Structure Provides an Attention Prior

Attention-derived sparsity is difficult to exploit early in denoising. Sparse attention reduces the cost of joint generation without removing all cross-scene interactions. Existing training-free methods select interactions using attention scores (Xia et al., 2025; Yang et al., 2026) or predefined spatial-temporal patterns (Li et al., 2026d; Zhang et al., 2025d). However, even with a sparse pattern avail-

SVG (Xi et al., 2025) SVG2 (Yang et al., 2026) Sol-Attn (Li et al., 2026a) Radial (Li et al., 2026d) STA (Zhang et al., 2025d) a

Share of denoising time spent in the dense steps.

Scene structure provides an attention prior before denoising. Unlike attention-score-based sparsity, multiscene requests provide structural information before generation begins. Scene durations determine which video tokens belong to each scene, while scene prompts specify their corresponding text conditioning (Fig. 4). This information identifies intra-scene attention regions without relying on intermediate attention scores. Although the request does not specify which cross-scene video representations are needed for consistency, it enables a natural decomposition: preserve complete attention within each scene while selectively sharing a bounded amount of information across scenes. Importantly, this structure is available from the first denoising

same collapsed tower same tower, 10 years earlier

S1 A drone passes a collapsed tower; a neon sign flickers.

S2 10 years ago: the signal tower stands pristine.

S3 Flying cars pass the tower's peak.

Recurring environment

Background

S4 A crowd gathers below the tower.

New element

S5 Back to now: the same collapsed tower.

Flashback

Figure 4: A request specifies scene boundaries and perscene prompts. Which content recurs is implicit and must be discovered at runtime. step, even when attention scores are too diffuse to support aggressive score-based sparsification.

3

S CENE -S TRUCTURED ATTENTION

We next introduce how OneReel decomposes multi-scene attention into complete scene-local computation and bounded cross-scene information sharing. We first describe how this decomposition maps to different model architectures using a unified scene-structured attention (§3.1), then how the shared memory is constructed and bounded (§3.2). 3.1

Scene-Structured Attention across Architectures

Given a request with K scenes, OneReel aims to associate each scene with its text conditioning while allowing selected video information to be shared across scenes. Let Vi denote the video tokens assigned to scene i by its duration, and Ti the tokens of its prompt. Scene boundaries determine which queries belong to each scene, but do not require those queries to access only local keys. Our assignment distinguishes query ownership, determined by scene boundaries, from attention scope, which determines which keys each query can access. For a given attention head, let Si denote the set of video keys accessible to video queries in scene i. It contains the full set Vi and a bounded subset of foreign video tokens selected by the sharing mechanism in Section 3.2. This abstraction specifies the logical information flow independently of the physical arrangement of tokens in memory. Supporting different model architectures. As shown in Fig. 5a, for MMDiT-style model architectures like HunyuanVideo, text and video tokens participate in joint attention. OneReel restricts video queries from scene i to its prompt tokens, its own video tokens, and selected video tokens from other scenes. Specifically, for each scene i, OneReel allows video queries to attend to Kivideo = Si ∪ Ti , while its text queries attend only to Kitext = Vi ∪ Ti . Thus, video queries may access selected foreign video representations, but text queries remain restricted to their corresponding scene. In models such as Wan2.2, video self-attention and text–

Figure 5: Scene-structured attention across model architectures. Rows denote queries and columns denote keys. Purple denotes scene-local interactions; orange denotes selected foreign video K/V from a shared memory. The example shows one head; text queries remain local.

video cross-attention are separate operations (Fig. 5b). OneReel applies the video-reading rule in self-attention and restricts cross-attention to the corresponding scene prompt. Therefore, both architectures apply the same logical principle: complete local video context, scene-specific text conditioning, and selective cross-scene video access. A shared video key may be read by multiple scenes, but each query produces exactly one output at its original position. 3.2

Cross-Scene Information Sharing

Scene-local attention preserves scene-specific information, but recurring subjects and scene transitions require crossscene sharing. Allowing every scene to read tokens from all others restores quadratic attention complexity. Even restricting sharing to a few frames per scene retains quadratic growth in scene count when every scene accesses all shared frames. Instead, OneReel bounds the total shared context using a memory of representative latent frames. The challenge is to keep this memory compact without discarding information useful for cross-scene consistency. Frame-level representation and selection. Rather than selecting individual tokens, OneReel selects complete latent frames as the units of cross-scene sharing. Each representative frame retains all its spatial tokens, preserving its complete spatial representation for receiving scenes. To identify representative frames, OneReel constructs a compact feature for each latent frame. During the conditional pass of denoising step t, it mean-pools the video hidden states at a designated selection layer over the spatial tokens within each frame and normalizes the resulting features. As shown in Fig. 6, OneReel groups these frame features into at most M clusters using k-means and selects the original frame nearest each cluster center. OneReel avoids re-

Figure 6: Bounded cross-scene sharing. At step t, OneReel mean-pools each latent frame and k-means assigns it a cluster ck and the frame nearest each centroid (orange) becomes a shared representative for step t+1, used by every layer and head. The initial step uses model-specific boundary frames.

Figure 7: Packing scene scopes for dense execution. OneReel appends copies of shared K/V to each scene’s local context, turning scattered accesses into contiguous inputs for dense variable-length attention.

peated selection by reusing representative frame indices across layers and heads within a denoising step, while adapting the shared frames using the recent step’s information.

4

Bounded cross-scene attention scopes. Let Rt denote the selected frame indices used at denoising step t, with |Rt | ≤ M . For each selected frame f , let V (f ) denote its complete S set of video tokens. The shared video-token set is Mt = f ∈Rt V (f ). With F video tokens per latent (t)

frame, |Mt | ≤ M F . Each scene i accesses Si = Vi ∪ (Mt \ Vi ). Thus, each scene retains all local video tokens while accessing at most M foreign frames, regardless of the number of scenes. Representatives originating from the receiving scene are excluded from its foreign context because their tokens are already available locally. Local and shared keys participate in the same attention softmax, allowing queries to combine scene-specific information with shared context. Text and other modalities follow the architecture-specific conditioning rules described above. We use M = 4 by default and examine the quality–latency trade-off of M in §5.5. Complexity Analysis of Scene-Structured Attention. Dense video attention computes L2 query–key pairs per head. The shared memory preserves intra-scene attention but limits each scene to at most M F additional video keys. The fraction of attention work retained relative to dense attention is therefore bounded by P X MF i ρi L |Si | ≤ ρ2i + . (1) L2 L i The first term accounts for intra-scene attention, while the second bounds cross-scene sharing. For equally sized scenes, this bound becomes 1/K + M F/L. With scene length and M fixed, both terms decrease in proportion to 1/K, so the retained attention work grows linearly rather than quadratically with scene count.

O NE R EEL RUNTIME

While scene-structured attention reduces the amount of computation, realizing these savings requires efficient GPU execution. Two challenges arise. First, each scene combines dense local attention with a bounded set of foreign K/V scattered across the video sequence. Executing such irregular scopes can underutilize attention kernels. Second, scenes differ in length and attention-scope size, making equal-token GPU partitioning insufficient for balancing computation. Distributing every scene across GPUs restores balance but incurs unnecessary remote K/V accesses. OneReel addresses these challenges by separating logical attention scopes from their physical execution. It packs the retained interactions into dense work (§4.1) and employs work-balanced, scene-aware partitioning with request-level communication selection (§4.2). 4.1

Packing Sparse Scopes into Dense Work

A straightforward way to execute scene-structured attention is to express its scopes as a block-sparse mask and invoke a sparse attention kernel (Zhang et al., 2025b; Li et al., 2026a; Ning et al., 2026). However, our attention scopes have a distinctive structure. Each scene retains a dense local region containing all its video tokens and accesses only a bounded number of foreign video tokens. Consequently, most retained computation occurs within dense regions, while irregularity is confined to a small shared context. This structure creates an opportunity to trade limited data replication for more efficient attention execution. Rather than preserving scattered K/V accesses through a sparse kernel, OneReel materializes the retained attention scopes as contiguous sequences. The additional replication is bounded by the shared-memory budget, while dense execution benefits the entire attention scope. Specifically, OneReel appends copies of the required foreign K/V to each scene’s local K/V (Fig. 7). For video

Table 2: Speedup over block-sparse execution on identical attention scopes. Packed execution includes per-layer K/V copying. K/V layout

Attention path

K=3

K=6

K = 12

Original Packed

Block-sparse Dense varlen

1.00× 1.83×

1.00× 1.72×

1.00× 1.68×

Block-sparse execution uses FlashInfer with FA3 for full blocks and FA2 for partial blocks. Packed execution uses FA3.

queries, the packed sequence contains the locally permitted keys and selected foreign video keys, excluding representatives already available locally. All video queries from the same scene reuse this prepared K/V sequence, amortizing the packing cost across their attention computation. Query classes with different key-access rules retain their architecture-specific scopes (§3.1). Because scenes can differ in length and in the number of foreign representatives, the resulting query and K/V sequences are variable-length. OneReel batches the packed videoquery scopes using dense variable-length attention (Shah et al., 2024), without padding them to a common length. The packed layout preserves the logical attention scopes and original positional information. Table 2 compares packed execution against block-sparse execution on identical attention scopes. Including per-layer K/V copying, packed dense execution achieves 1.68–1.83× speedup. Thus, the higher throughput of dense attention outweighs the bounded data-replication overhead. We next describe how the required K/V are distributed across GPUs. 4.2

Work-Balanced Multi-GPU Execution

Algorithm 1 Work-Balanced Scene Partitioning Require: Ordered scenes with length fractions {ρi }K i=1 , total video-token count L, attention scopes {Si }K i=1 , and P GPUs Ensure: Query ranges Πp assigned to each GPU p 1: a0 ← 0; W0 ← 0 2: for i = 1, . . . , K do 3: ci ← |Si | {Attention work per video query} 4: ai ← ai−1 + ρi L 5: Wi ← Wi−1 + ρi Lci {Total attention workload} 6: end for 7: W̄ ← WK /P {Target work per GPU} 8: b0 ← 0; bP ← L 9: for p = 1, . . . , P − 1 do 10: i ← min{j : Wj ≥ pW̄ }
11: r ← round (pW̄ − Wi−1 )/ci 12: bp ← ai−1 + r 13: end for 14: for p = 1, . . . , P do 15: Πp ← S CENE R ANGES([bp−1 , bp )) 16: end for 17: return {Πp }P p=1

Let scene i contain ni = ρi L video tokens, and let ci denote its estimated attention work per video query, proportional to |Si |. Its total video-attention workload is wi = ni ci . Thus, equal query counts can produce unequal GPU workloads. Assigning each GPU an equal fraction of every scene’s queries would balance attention work, but unnecessarily fragment scenes across GPUs, requiring remote K/V transfers even for intra-scene attention.

Scene-structured attention changes both the computational workload and the K/V dependencies of multi-GPU execution. Placing complete scenes on individual GPUs preserves local K/V but can leave computation imbalanced. Conversely, distributing every scene across GPUs balances computation but requires remote K/V exchange even for intra-scene attention. OneReel addresses this trade-off with a lightweight two-stage approach. It constructs workbalanced partitions that preserve complete scenes whenever possible and compares the estimated communication time of K/V gathering and Ulysses-style execution (Fang & Zhao, 2024), selecting one path for the request.

OneReel employs work-balanced contiguous partitioning. It traverses scenes in temporal order and accumulates their estimated attention work (Alg. 1, Lines 3–5). For P GPUs, it places partition boundaries PK at successive multiples of the target workload W̄ = P1 i=1 ni ci . A scene remains intact when partition boundaries fall outside it; otherwise, only the boundaries falling within the scene split its queries (Line 12). Because partitions are contiguous, at most P − 1 boundaries can split scenes. This construction approximately balances computation while preserving complete scenes whenever the workload boundaries permit. It does not directly minimize communication, but avoids the systematic fragmentation caused by distributing every scene across GPUs.

Balancing attention work while preserving locality. Under dense global attention, assigning equal numbers of queries approximately balances attention computation because every query accesses the same global key sequence. This no longer holds under scene-structured attention: queries from different scenes access scopes containing different numbers of keys.

Queries and their associated local K/V follow the same partition. An intact scene requires no remote K/V for intra-scene attention. For a split scene, each GPU gathers only the missing K/V needed by its assigned queries. Cross-scene representatives are exchanged when their source tokens reside on other GPUs. The resulting K/V are organized using the packed layout described in §4.1.

Optimizing the communication path. The advantage of locality-aware execution depends on how scenes are distributed across GPUs. When scenes fit within individual GPUs, their intra-scene attention requires no remote K/V transfers. However, when a large scene must be partitioned to balance computation, each participating GPU must access the scene’s complete K/V across all attention heads. As the scene spans more GPUs, the resulting K/V replication can incur substantial communication. Ulysses-style parallelism (Fang & Zhao, 2024) offers an alternative by redistributing attention tensors across heads, allowing each GPU to process the full sequence for some heads. This benefit depends on collective bandwidth, so OneReel compares the estimated communication time of the two paths. We first consider video attention without shared frames. Let D denote the bytes occupied by one token in one tensor across all attention heads, and let θ denote the effective bandwidth of K/V gathering relative to all-to-all. In the pureUlysses configuration of USP, Q, K, V, and the attention output are redistributed through all-to-all. Query-partitioned execution instead keeps queries and outputs local and gathers the missing K/V. Under the bandwidth-based cost model, gathering is preferable when X 4LD(P − 1) . (2) 2D max (ρi L − xp,i ) < θ p P{z2 | } i:xp,i >0 | {z } VU VG

The left-hand side depends on which scenes the partition splits and how much of each remains local. The right-hand side depends on the full sequence length and GPU count. We take the work-balanced gathering path when its estimated communication is smaller and fall back to USP otherwise. We next show how scene structure affects P the choice between K/V gathering and USP. Let S = i ρ2i and ρmax = maxi ρi . The total attention work is proportional to SL2 , giving each GPU a target workload of SL2 /P . This budget limits how much of the longest scene can remain on one GPU, yielding a lower bound on the required remote K/V:   S VG ≥ 2LD ρmax − . (3) P ρmax Combining this bound with Eq. 2 gives the following necessary condition for lower communication time than USP: ρmax −

S 2θ(P − 1) < . P ρmax P2

5

E VALUATION

We evaluate OneReel across video generation models and multi-scene requests. Our results show that OneReel achieves 1.7–4.9× end-to-end speedups over dense attention and 1.2–2.2× over the strongest evaluated sparseattention baseline. Meanwhile, OneReel also improves scene-level text alignment over dense generation. 5.1

Evaluation Setup

We implement a prototype of OneReel atop the popular video-generation engine, xDiT (Fang et al., 2024), for broad applicability. Detailed implementations are available in Appendix F. Models and Workloads. We evaluate OneReel on Wan2.2, HunyuanVideo-1.5, MiniMax H3, and CogVideoX1.5 at resolutions of 480p and 720p, using 20 denoising steps. All experiments run on 8xH200 GPUs connected by NVLink. We adapt multi-scene requests from HoloCine (Meng et al., 2025), Shot2Story (Han et al., 2025), and MSVBench (Shi et al., 2026), and supplement them with LLM-written scripts covering flashbacks, cross-cutting, recurring objects, and returning locations. Requests contain 3–12 scenes and specify videos up to 24 s. Baselines. We compare against three types of generation advances. (1) Dense uses each model’s original full attention with FlashAttention. (2) Separate generates each scene independently using its own prompt and concatenates the results. (3) Sparse attention includes Radial Attention (Li et al., 2026d), Sparse VideoGen (Xi et al., 2025), and SolAttn (Li et al., 2026a), using their released attention patterns, sparsity settings, and warm-up configurations. For multiGPU execution, we additionally compare against Ulysses at matched GPU counts. Appendix D further evaluates a balanced USP oracle inspired by db-SP (Chen et al., 2026) Efficiency metrics. We report end-to-end generation latency, denoising time, and per-step diffusion forward time. For multi-GPU execution, we measure data transferred per GPU and exposed communication time, together with latency scaling across GPU counts and speedup over USP. Load imbalance is measured as the maximum per-GPU attention workload divided by the average.

(4)

This condition connects the execution choice to the distribution of scene structures: OneReel can tolerate modest imbalance in scene structure while maintaining balanced attention workloads and preserving sufficient K/V locality to reduce communication. The derivation and communication accounting for complete attention scopes are detailed in Appendix E.

Quality Metrics. Our evaluations include popular, objective metrics and LLM as a judge for scalable evaluation. Specifically, we split videos at the planned scene boundaries. First, we use CLIP to measure the fraction of scenes whose frames best match their own prompt among all scene prompts (Text). We additionally require cross-scene DINOv2 similarity above the 95th percentile of differentsubject pairs (Text+ID). Second, we use VBench to as-

480p Latency (s)

Dense HunyuanVideo-1.5 400

3.3× vs Dense 1.20× vs Best sparse

Radial SVG Wan2.2-5B 50

0

720p Latency (s)

6

9

12 120

1000

6

9

2.4× vs Dense 1.45× vs Best sparse

6

9

12

9

12

2.6× vs Dense 1.51× vs Best sparse

15

6

1200

4.0× vs Dense 2.22× vs Best sparse

0

Video length (s)

6

9

12

18

24

600

400

3

2.6× vs Dense 1.73× vs Best sparse

0 6

800

0 3

200 100

12

60

0

2.0× vs Dense 1.33× vs Best sparse

0 3

4.9× vs Dense 1.31× vs Best sparse

OneReel CogVideoX1.5-5B

150

0 3

2000

300

1.7× vs Dense 1.27× vs Best sparse

25

200

Sol-Attn Separate MiniMax-H3

0

12

6

Video length (s)

9

12

15

6

Video length (s)

12

18

24

Video length (s)

Figure 8: End-to-end latency of multi-scene video generation against video length. Speedup numbers are computed at the longest video. Sol-Attn is omitted on CogVideoX1.5, due to kernel not support.

CLIP / DINOv2 Method

VBench

Gemini 2.5 Pro

Text Text+ID Img. Aes. Dyn. Action W/T/L

HunyuanVideo-1.5, 480p Dense 27.7 4.9 Radial 28.3 5.1 SVG 31.2 9.6 Sol-Attn 30.0 6.9 OneReel 61.9 24.3

61.7 62.1 58.7 67.4 63.2

57.0 56.8 55.5 59.4 58.9

95.0 95.0 97.5 97.5 97.5

34.5 38.4 39.9 40.1 64.1

33/4/3 32/4/4 31/7/2 30/9/1 NA

Wan2.2-5B, 720p Dense 25.0 6.2 Radial 22.6 4.6 SVG 23.5 3.6 Sol-Attn 24.4 1.5 OneReel 61.6 30.1

65.3 65.9 66.0 65.4 66.2

55.5 55.6 55.9 56.6 57.5

50.0 52.5 52.5 50.0 85.0

23.4 27.3 24.6 27.5 50.1

34/3/3 31/7/2 37/2/1 35/4/1 NA

sess imaging quality, aesthetic quality, and dynamic degree (Huang et al., 2023). Third, we use Gemini 2.5 Pro to assess scene-level action accuracy (Action) and record blind pairwise wins/ties/losses for OneReel (W/T/L). 5.2

End-to-End Performance

OneReel accelerates multi-scene generation across models and resolutions. Figure 8 compares end-to-end latency as requests grow from 3 to 12 scenes at 480p and 720p. At twelve scenes, OneReel achieves 1.7–4.9× speedups over dense attention and 1.2–2.2× over the fastest sparseattention baseline across the four models. Its advantage over dense attention grows with video length, increasing from 1.6× to 4.9× on HunyuanVideo-1.5 at 720p.

Dense

Speed-up over Dense

Table 3: Generation quality on 40 multi-scene requests (%, except W/T/L; metrics in §5.1). Best and second-best scores are bold and underlined. (W/T/L) reports OneReel’s wins/ties/losses over the baseline.

4

4.0×

Radial

SVG 3.9×

Sol-Attn

OneReel

3.5× 3.1×

3 2 1 0

1 GPU (236 s)

2 GPUs (127 s)

4 GPUs (70 s)

8 GPUs (42 s)

Figure 9: Speed-up of denoising over Dense attention when scaling to more GPUs.

OneReel improves scene following while preserving visual quality. Table 3 shows that the latency reduction is accompanied by better adherence to the requested scenes. We evaluate the compared joint-generation methods on 40 requests comprising 203 scenes using HunyuanVideo-1.5 and Wan2.2. OneReel achieves Text following scores of 61.6–61.9%, compared with 23–31% for dense and sparseattention baselines, and also improves Text+ID. These improvements are accompanied by higher imaging and aesthetic scores than dense attention and consistent preference in blind pairwise comparisons. OneReel retains its latency advantage across GPU counts. Figure 9 evaluates OneReel’s scalability on one to eight GPUs. OneReel is the fastest method at every GPU count, reducing denoising time from 236 s on one GPU to 42 s on eight. With only two GPUs, it matches dense attention on eight GPUs (127 s versus 129 s). Across these configurations, OneReel achieves 3.1–4.0× speedups over dense attention. For this fixed request, increasing the GPU count leaves less attention work per device, making per-step overheads relatively more prominent. This limits the relative

16 s

24 s

Summer, oak tree

Puppy splashes boy

Dense

OneReel 31 s

40 s

48 s

56 s

Boy rakes leaves

Winter, snow

Boy, puppy by fire

Boy, dog under oak

Attention GEMM

Dense

Other kernels Exposed comm. (NVLink)

HunyuanVideo-1.5

8

35.6 / 37.3 s

9s Puppy, butterfly

GPU time per forward (s)

1s Spring, oak tree

4

68 GB

12

0

3% 29%

2% 15%

3% 24%

3

6% 40%

2 3.9× less

UlyssesUlysses Ring OneReel Dense attn.

Wan2.2-5B

4 2% 9%

Extra on PCIe Data sent / GPU

14 GB

1 0

1% 3% 5.8× less

UlyssesUlysses Ring OneReel Dense attn.

Scene attn.

3% 30%

Scene attn.

Figure 11: Per-forward GPU time and communication volume under NVLink and PCIe.

OneReel Mean over four requests · Dense → OneReel Text: 2.6% → 61.0% Latency: 4,896 → 608 s (8.1×)

Figure 10: Minute-long generation with HunyuanVideo-1.5. OneReel captures the requested scene changes, while dense generation remains visually repetitive.

S1: detective reads a note

S2: informant hurries

S3: detective enters bar

S4: informant opens door

Full prompt, all frames no informant

no informant

no informant

no informant

Own prompt, all frames

Table 4: Runtime reuse on HoloCine with its native crossscene attention policy.

Own prompt, own scene style break

Execution

GPUs

Forward (s)

End-to-end (s)

Own prompt, own + adjacent scene

Official Ulysses OneReel

1 2 2

4.49 2.45 2.24

463.5 261.3 239.8

Own prompt, own + memory (OneReel)

mixed identity

Figure 12: Visual comparison of attention scopes. gains from attention reduction. 5.4 5.3

Performance Breakdown

Long-Video Generation and Runtime Reuse

OneReel extends to minute-long multi-scene generation. Figure 10 illustrates generation for one-minute requests containing 26–34 scenes. Without fine-tuning, OneReel raises scene-level Text accuracy from 2.6% to 61.0%, while reducing end-to-end latency by 8.1×. The accompanying frames illustrate changes that dense generation fails to reproduce. Appendix A presents the complete results and examines the contributions of scene-structured attention and RoPE. OneReel complements existing multi-scene video generation. We further test whether OneReel’s runtime can accelerate native multi-scene models without changing their attention policies. We demonstrate this reuse on HoloCine (Meng et al., 2025) through a thin adapter that exposes its query ranges and K/V scopes, preserving its original attention policy rather than replacing it with our bounded-memory design. As shown in Table 4, OneReel reduces forward latency by 8.6% and end-to-end latency by 8.2% relative to Ulysses on the same two H200 GPUs. Compared with the official single-GPU implementation, OneReel on two GPUs achieves a 1.93× end-to-end speedup and produces an identical video after 50 denoising steps.

Scene-structured execution reduces attention time and K/V traffic. Figure 11 separates the effects of attention reduction and multi-GPU execution. Keeping Ulysses unchanged, replacing dense attention with scene-structured attention substantially reduces attention time, but leaves communication volume largely unchanged. Restricting attention scopes therefore removes computation without automatically eliminating the K/V transfers performed by conventional sequence parallelism. On identical scene-structured scopes, OneReel reduces the data sent per GPU by approximately 3.9× on HunyuanVideo-1.5 and 5.8× on Wan2.2 relative to Ulysses. This reduction is particularly beneficial under limited bandwidth. In the PCIe setting, exposed communication accounts for 40% of GPU time on Wan2.2 with Ulysses, compared with 3% with OneReel. Under NVLink, communication occupies a smaller fraction of execution time. These results show how preserving locality benefits attention reduction. Scene-local attention and bounded sharing balance scene following and consistency. Table 5 shows that scenespecific prompts alone are insufficient for strong scene fol-

Table 5: Quality under different attention scopes. Video scope

Text

Action

Text+ID

Full Own Own Own Own

All frames All frames Own scene Own + neighbors Own + memory

27.7 34.9 60.8 58.0 61.9

34.5 31.2 61.3 55.0 64.1

4.9 10.3 17.0 25.4 24.3

longest > 50%

1.5

1.89× 1.25×

1

≤1.03× 25 36 46 57 68 79 89

Longest scene's share (%)

61.9

60 40

800

Text Text+ID Latency

400 20 0

Latency (s)

2

OneReel Partition by tokens Partition by scenes

Quality (%)

Busiest GPU / mean

Prompt

24.3 314 333 347 373 429

0 1 2 4(ours) 8 Shared frames (𝘔)

0

Figure 13: Attention-work Figure 14: Effect of sharedimbalance across scene- frame budget M on quality length distributions. (lines) and latency (bars). lowing. With each scene attending to its own prompt, restricting video attention from all frames to its own scene raises Text from 34.9 to 60.8. The improvement therefore depends not only on assigning the correct prompt, but also on limiting the video information exchanged across scenes. Shared memory complements this separation by providing cross-scene context. Adding it to scene-local attention raises Text+ID from 17.0 to 24.3 without reducing Text or Action. Compared with adjacent-scene sharing, memory achieves higher Text and Action at a slightly lower Text+ID score. Figure 12 illustrates the role of this shared context. Local-only generation distinguishes the requested characters but introduces a style discontinuity, while memory sharing maintains a coherent appearance across the distinct scenes. 5.5

Sensitivity Analysis and Ablation Studies

Work-balanced partitioning tolerates unequal scene lengths. Figure 13 varies the longest scene’s share from 25% to 89% on two GPUs. By accounting for per-query cost and splitting oversized scenes, Algorithm 1 reduces the maximum-to-mean workload ratio by factors of up to 1.25 and 1.89 relative to token- and scene-based partitioning, respectively. Across all tested layouts, the maximum per-GPU workload remains within 1.03× the mean. Four shared frames offer a practical quality–latency trade-off. Figure 14 varies the shared-frame budget from M = 0 to M = 8. Our default M = 4 raises Text+ID from 17.0 to 24.3 relative to no sharing, with a 19% increase in latency. Doubling the budget to M = 8 provides only an-

other 2.3 percentage points of Text+ID improvement while adding 15% latency and reducing Text. The four-frame budget captures most of the observed Text+ID gain. Impact of scene granularity and intra-scene sparsity. Additional experiments show that finer scene partitioning reduces latency even at a fixed video length (Appendix B). Combining OneReel with intra-scene sparse attention provides further acceleration, particularly for longer scene-local contexts (Appendix C).

6

R ELATED W ORK

Efficient Diffusion Inference. Prior work accelerates diffusion attention through low-precision kernels (Zhang et al., 2025a) and spatial-temporal sparsity (Xi et al., 2025; Zhang et al., 2025d). Sparse VideoGen2 (Yang et al., 2026) further clusters and reorders tokens to improve sparse execution. For multi-GPU inference, USP (Fang & Zhao, 2024) and xDiT (Fang et al., 2024) provide sequence and hybrid parallelism, while PipeFusion (Fang et al., 2025) pipelines computation across patches and model stages. DSA (Li et al., 2026b) combines sparse attention with distributed execution. These efforts demonstrate the importance of matching attention patterns with execution strategies. OneReel uses the scene structure to define attention scopes and exploits their dense local regions and bounded shared context. Long and Multi-Scene Video Generation. StreamingT2V (Henschel et al., 2025) and LongLive (Yang et al., 2025) extend videos through autoregressive generation and context reuse, while Stable Video Infinity (Li et al., 2026c) addresses accumulated errors through error-recycling training. For multi-prompt generation, DiTCtrl (Cai et al., 2025) provides training-free attention control. HoloCine (Meng et al., 2025) trains a multi-shot model with shot-specific text conditioning and dense intra-shot but sparse inter-shot attention. OneReel likewise distinguishes local scene content from shared information, but supports multiple pretrained attention architectures without retraining.

7

C ONCLUSION

OneReel is a training-free system for efficient multi-scene video generation. Its scene-structured attention preserves scene-specific conditioning and dense local context while bounding cross-scene sharing. The runtime packs these attention scopes for dense-kernel execution and balances attention work across GPUs while exploiting scene locality. Across four models, OneReel achieves 1.7–4.9× end-toend speedups over dense attention and 1.2–2.2× over the fastest sparse-attention baseline. Quality evaluations show improved scene following while preserving visual quality.

R EFERENCES Alibaba Cloud. Video generation model Wan3.0 officially launched. https://www.alibabacloud.com/e n/news/product/video-generation-model -wan30-officially-launched-nsb, 2026. Official product announcement, August 24, 2026. Accessed: October 14, 2026. Cai, M., Cun, X., Li, X., Liu, W., Zhang, Z., Zhang, Y., Shan, Y., and Yue, X. Ditctrl: Exploring attention control in multi-modal diffusion transformer for tuning-free multiprompt longer video generation. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7763–7772. IEEE, 2025. Chen, S., Hong, K., Zhao, T., Xie, R., Zhu, Z., Zhang, X., and Wang, Y. db-SP: Accelerating sparse attention for visual generative models with dual-balanced sequence parallelism. Proceedings of Machine Learning and Systems, 8:123–137, 2026. Fang, J. and Zhao, S. A unified sequence parallelism approach for long context generative ai. arXiv preprint arXiv:2405.07719, 2024. Fang, J., Pan, J., Sun, X., Li, A., and Wang, J. xDiT: an inference engine for diffusion transformers (DiTs) with massive parallelism. arXiv preprint arXiv:2411.01738, 2024. Fang, J., Pan, J., Li, A., Sun, X., and Jiannan, W. Pipefusion: Patch-level pipeline parallelism for diffusion transformers inference. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025. URL ht tps://openreview.net/forum?id=5xwyxu psLL. Gao, Y., Guo, H., Hoang, T., Huang, W., Jiang, L., Kong, F., Li, H., Li, J., Li, L., Li, X., Li, X., Li, Y., Lin, S., Lin, Z., Liu, J., Liu, S., Nie, X., Qing, Z., Ren, Y., Sun, L., Tian, Z., Wang, R., Wang, S., Wei, G., Wu, G., Wu, J., Xia, R., Xiao, F., Xiao, X., Yan, J., Yang, C., Yang, J., Yang, R., Yang, T., Yang, Y., Ye, Z., Zeng, X., Zeng, Y., Zhang, H., Zhao, Y., Zheng, X., Zhu, P., Zou, J., and Zuo, F. Seedance 1.0: Exploring the boundaries of video generation models. arXiv preprint arXiv:2506.09113, 2025. Ghermi, R., Wang, X., Kalogeiton, V., and Laptev, I. Long story short: Story-level video understanding from 20k short films. International Journal of Computer Vision, 134(8):396, 2026. Han, M., Yang, L., Chang, X., Yao, L., and Wang, H. Shot2story: A new benchmark for comprehensive understanding of multi-shot videos. In International Con-

ference on Learning Representations, volume 2025, pp. 41665–41677, 2025. Henschel, R., Khachatryan, L., Poghosyan, H., Hayrapetyan, D., Tadevosyan, V., Wang, Z., Navasardyan, S., and Shi, H. Streamingt2v: Consistent, dynamic, and extendable long video generation from text. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2568–2577, June 2025. Huang, Z., He, Y., Yu, J., Zhang, F., Si, C., Jiang, Y., Zhang, Y., Wu, T., Jin, Q., Chanpaisit, N., Wang, Y., Chen, X., Wang, L., Lin, D., Qiao, Y., and Liu, Z. VBench: Comprehensive benchmark suite for video generative models, 2023. URL https://arxiv.org/abs/2311.1 7982. Kong, W., Tian, Q., Zhang, Z., Min, R., Dai, Z., Zhou, J., Xiong, J., Li, X., Wu, B., Zhang, J., Wu, K., Lin, Q., Yuan, J., Long, Y., Wang, A., Wang, A., Li, C., Huang, D., Yang, F., Tan, H., Wang, H., Song, J., Bai, J., Wu, J., Xue, J., Wang, J., Wang, K., Liu, M., Li, P., Li, S., Wang, W., Yu, W., Deng, X., Li, Y., Chen, Y., Cui, Y., Peng, Y., Yu, Z., He, Z., Xu, Z., Zhou, Z., Xu, Z., Tao, Y., Lu, Q., Liu, S., Zhou, D., Wang, H., Yang, Y., Wang, D., Liu, Y., Jiang, J., and Zhong, C. Hunyuanvideo: A systematic framework for large video generative models. arXiv preprint arXiv:2412.03603, 2024. Li, H., Li, Y., Chen, J., Ye, T., Liu, H., Yu, J., Wang, D., Zhang, R., Xie, Z., Xie, E., et al. Sol-attn: Accelerating video generation inference via on-the-fly attention sparsification. arXiv preprint arXiv:2607.24027, 2026a. Li, S., Lu, R., qiaoling chen, Yin, H., Lyu, Y., Wen, Y., Tsang, I., and Zhang, T. DSA: Efficient inference for video generation models via distributed sparse attention. In The Fourteenth International Conference on Learning Representations, 2026b. URL https://openrevi ew.net/forum?id=1ZmdfDzGE1. Li, W., Pan, W., Luan, P.-C., Gao, Y., and Alahi, A. Stable video infinity: Infinite-length video generation with error recycling. In The Fourteenth International Conference on Learning Representations, 2026c. URL https:// openreview.net/forum?id=X96Ei9n34a. Li, X., Li, M., Cai, T., Xi, H., Yang, S., Lin, Y., Zhang, L., Yang, S., Hu, J., Peng, K., et al. Radial attention: O(n log n) sparse attention with energy decay for long video generation. Advances in Neural Information Processing Systems, 38:16822–16852, 2026d. Meng, Y., Ouyang, H., Yu, Y., Wang, Q., Wang, W., Cheng, K. L., Wang, H., Li, Y., Chen, C., Zeng, Y., Shen, Y., and Qu, H. HoloCine: Holistic generation of cinematic multi-shot long video narratives, 2025. URL https: //arxiv.org/abs/2510.20822.

MiniMax. MiniMax H3: An open model breaking the boundaries between tasks and modalities. https: //www.minimax.io/blog/minimax-h3, 2026. Official announcement, July 31, 2026. Accessed: October 14, 2026. Ning, R., Zhang, W., and Lai, F. Packinfer: Compute- and i/o-efficient attention for batched llm inference, 2026. URL https://arxiv.org/abs/2602.06072. Shah, J., Bikshandi, G., Zhang, Y., Thakkar, V., Ramani, P., and Dao, T. Flashattention-3: Fast and accurate attention with asynchrony and low-precision. Advances in Neural Information Processing Systems, 37:68658–68685, 2024. Shi, H., Li, Y., Deng, N., Xu, Z., Chen, X., Wang, L., Hu, B., and Zhang, M. Msvbench: Towards human-level evaluation of multi-shot video generation. In Findings of the Association for Computational Linguistics: ACL 2026, pp. 24034–24058, 2026. Wan, T., Wang, A., Ai, B., Wen, B., Mao, C., Xie, C.-W., Chen, D., Yu, F., Zhao, H., Yang, J., Zeng, J., Wang, J., Zhang, J., Zhou, J., Wang, J., Chen, J., Zhu, K., Zhao, K., Yan, K., Huang, L., Feng, M., Zhang, N., Li, P., Wu, P., Chu, R., Feng, R., Zhang, S., Sun, S., Fang, T., Wang, T., Gui, T., Weng, T., Shen, T., Lin, W., Wang, W., Wang, W., Zhou, W., Wang, W., Shen, W., Yu, W., Shi, X., Huang, X., Xu, X., Kou, Y., Lv, Y., Li, Y., Liu, Y., Wang, Y., Zhang, Y., Huang, Y., Li, Y., Wu, Y., Liu, Y., Pan, Y., Zheng, Y., Hong, Y., Shi, Y., Feng, Y., Jiang, Z., Han, Z., Wu, Z.-F., and Liu, Z. Wan: Open and advanced large-scale video generative models. arXiv preprint arXiv:2503.20314, 2025. Wang, Q., Shi, X., Li, B., Bian, W., Liu, Q., Lu, H., Wang, X., Wan, P., Gai, K., and Jia, X. Multishotmaster: A controllable multi-shot video generation framework. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 16268–16278, 2026. Xi, H., Yang, S., Zhao, Y., Xu, C., Li, M., Li, X., Lin, Y., Cai, H., Zhang, J., Li, D., Chen, J., Stoica, I., Keutzer, K., and Han, S. Sparse video-gen: Accelerating video diffusion transformers with spatial-temporal sparsity. In Fortysecond International Conference on Machine Learning, 2025. URL https://openreview.net/forum ?id=u8CA3qIS0V. Xia, Y., Ling, S., Fu, F., Wang, Y., Li, H., Xiao, X., and Cui, B. Training-free and adaptive sparse attention for efficient long video generation. In 2025 IEEE/CVF International Conference on Computer Vision (ICCV), pp. 15982–15993. IEEE, 2025. Yang, S., Huang, W., Chu, R., Xiao, Y., Zhao, Y., Wang, X., Li, M., Xie, E., Chen, Y., Lu, Y., Han, S., and Chen,

Y. Longlive: Real-time interactive long video generation. arXiv preprint arXiv:2509.22622, 2025. Yang, S., Xi, H., Zhao, Y., Li, M., Zhang, J., Cai, H., Lin, Y., Li, X., Xu, C., Peng, K., et al. Sparse videogen2: Accelerate video generation with sparse attention via semantic-aware permutation. Advances in Neural Information Processing Systems, 38:96965–96991, 2026. Yang, Z., Teng, J., Zheng, W., Ding, M., Huang, S., Xu, J., Yang, Y., Hong, W., Zhang, X., Feng, G., Yin, D., Zhang, Y., Wang, W., Cheng, Y., Xu, B., Gu, X., Dong, Y., and Tang, J. Cogvideox: Text-to-video diffusion models with an expert transformer. arXiv preprint arXiv:2408.06072, 2024. Zhang, J., Huang, H., Zhang, P., wei, J., Zhu, J., and Chen, J. Sageattention2: Efficient attention with thorough outlier smoothing and per-thread INT4 quantization. In Fortysecond International Conference on Machine Learning, 2025a. URL https://openreview.net/forum ?id=nC8XliUxeg. Zhang, J., Xiang, C., Huang, H., wei, J., Xi, H., Zhu, J., and Chen, J. Spargeattention: Accurate and trainingfree sparse attention accelerating any model inference. In Forty-second International Conference on Machine Learning, 2025b. URL https://openreview.net /forum?id=74c3Wwk8Tc. Zhang, K., Jiang, L., Wang, A., Fang, J. Z., Zhi, T., Yan, Q., Kang, H., Lu, X., and Pan, X. Storymem: Multishot long video storytelling with memory. arXiv preprint arXiv:2512.19539, 2025c. Zhang, P., Chen, Y., Su, R., Ding, H., Stoica, I., Liu, Z., and Zhang, H. Fast video generation with sliding tile attention. arXiv preprint arXiv:2502.04507, 2025d. Zhou, Y., Zhou, D., Cheng, M.-M., Feng, J., and Hou, Q. Storydiffusion: Consistent self-attention for long-range image and video generation. Advances in Neural Information Processing Systems, 37:110315–110340, 2024.

Four seasons (32 scenes) 1s

9s

Spring, oak tree

Puppy, butterfly

16 s

24 s

31 s

Summer, oak tree Puppy splashes boy Boy rakes leaves

40 s Winter, snow

48 s

56 s

Text

Boy, puppy by fire Boy, dog under oak

Dense

0.03

Dense + scene-local RoPE

0.03

OneReel w/o scene-local RoPE

0.56

OneReel

0.72

Lighthouse keeper (30 scenes) 1s

7s

16 s

Dawn, lighthouse

Keeper, lens

Girl laughs

25 s

32 s

Girl, keeper in boat Sail snaps in wind

40 s Storm at night

49 s

56 s

Text

Lens beam sweeps Keeper's logbook

Dense

0.03

Dense + scene-local RoPE

0.03

OneReel w/o scene-local RoPE

0.43

OneReel

0.57

Figure 15: Representative frames from one-minute-long requests. Scene-structured attention improves scene differentiation, while scene-local RoPE reduces late-video artifacts. Text scores are reported separately for each request.

A

M INUTE -L ONG M ULTI -S CENE G ENERATION

We evaluate pretrained HunyuanVideo-1.5 without finetuning at 480p on two H200 GPUs with 20 denoising steps. Table 6 compares dense generation and OneReel, each with and without scene-local RoPE, on one-minute requests containing 1,421 frames and 26–34 scenes. Scene-local RoPE assigns Q and K temporal coordinate τ − ai , where τ is the global latent-frame index and ai is scene i’s starting index. Shared frames retain their source-scene coordinates regardless of the destination scene or packed position. Dense attention exposes each query to content from all scenes, allowing unrelated content to compete with its own scene. OneReel restricts this context while retaining scenespecific conditioning. Figure 15 shows that dense generation remains visually repetitive even with scene-local RoPE, whereas OneReel without positional adaptation already produces distinct scenes. Across four settings, this configuration raises Text accuracy from 2.6% to 47.2% (Table 6). These improvements in scene following do not, however, eliminate late-video degradation. Under global RoPE, a compact attention scope can still include shared keys at large

temporal separations. In the illustrated examples, OneReel without scene-local RoPE exhibits pronounced texture and color artifacts in later frames. Scene-local RoPE adjusts these positional relationships, reduces the observed artifacts, and further raises mean Text accuracy to 61.0% without increasing measured latency. Scene structure and positional adaptation therefore play complementary roles, improving scene following and mitigating long-horizon visual degradation, respectively. Table 6: Effects of scene-structured attention and scenelocal RoPE on minute-long generation. Scene-structured attention improves text following and reduces latency, while scene-local RoPE further improves text following without additional measured latency. Method

Text ↑

Latency (s) ↓

Dense Dense + local RoPE OneReel w/o local RoPE OneReel

2.6% 3.5% 47.2% 61.0%

4,896 4,902 608 608

Dense

Separate

OneReel

HunyuanVideo-1.5

Wan2.2-5B

Speedup over Dense

3.4×

per-scene overhead

3

1.5

2

1.0

1

0.5

0

0.0 1

2

4

6

12

1

Scenes in a 14 s video

2

4

6

1.7×

12

Scenes in a 14 s video

Figure 16: Speedup over dense generation as a fixed-length video (14 s, 480p) is divided into more scenes.

Speed-up over Dense

Dense

3 2

Sol-Attn +51%

OneReel

OneReel + Sol-Attn

+20%

+6%

+98%

1 0

6 4 1 2 (84) (42) (21) (14) Scenes in a 14 s video (latent frames per scene)

Figure 17: Combining scene-structured and intra-scene sparse attention on a fixed 14 s video. Percentages indicate additional denoising-step speedup over OneReel.

B

E FFECT OF S CENE N UMBERS

We vary the number of scenes while fixing the total video length at 14 s and the resolution at 480p. This separates the effect of scene structure from changes in video duration. As shown in Figure 16, increasing the scene count from one to twelve yields a 3.4× speedup on HunyuanVideo1.5 and a 1.7× speedup on Wan2.2 relative to one-scene execution. Dividing the same video into smaller scenes reduces the dense intra-scene attention workload, while cross-scene sharing remains bounded (§3.2). These savings bring OneReel close to the latency of separate generation despite retaining cross-scene information exchange. On HunyuanVideo-1.5, its latency stays within 3% of separate generation for 2–6 scenes. At twelve scenes, OneReel is faster than separate generation on both models, with a 1.34× advantage on Wan2.2. Scene structure therefore provides an additional source of efficiency even when the total video length is unchanged.

C

C OMBINING O NE R EEL WITH I NTRA -S CENE S PARSE ATTENTION

Scene-structured attention and intra-scene sparse attention reduce computation at different levels. OneReel restricts cross-scene interactions but retains dense attention within each scene, leaving further opportunities for sparsification

when individual scenes have long contexts. We combine the two by applying sparse attention to scene-local video keys while keeping attention to shared frames and text exact. We use Sol-Attn (Li et al., 2026a), the best-performing sparse-attention baseline in this setting, as a representative implementation. Figure 17 evaluates the combination on a fixed 14 s HunyuanVideo-1.5 video at 480p on two H200 GPUs, divided into one to six scenes. With a single long scene, OneReel has no cross-scene computation to remove, but intra-scene sparsification provides a 1.99× denoising-step speedup over dense attention. With two to six scenes, the combination achieves 2.49–2.81× speedups over dense attention and is 1.28–1.45× faster than sparse attention alone. The two techniques thus address different scene structures. For fewer, longer scenes, intra-scene sparsity provides substantial additional savings, reaching 1.51× over OneReel with two scenes. As scenes become shorter, scene-structured attention removes more computation, and the additional gain falls to 6% with six scenes. Combining the two extends acceleration across both long and short scene-local contexts.

D

C OMPARISON WITH BALANCED S EQUENCE PARALLELISM

To examine the benefit of scene locality beyond workload balancing, we compare OneReel against balanced Ulysses and Ring layouts, motivated by db-SP’s workloadbalancing approach (Chen et al., 2026). Both layouts use the same scene-structured attention scopes, frame memory, and packed FA3 kernels as OneReel. Ulysses partitions equally loaded heads, while Ring assigns each GPU an equal share of every scene. We call the faster layout for each request and interconnect the balanced USP oracle, excluding planning and migration overhead. We evaluate HunyuanVideo-1.5 at 720p on two H200 GPUs with M = 4. We vary either request duration from 3–20 s, averaging seven latent frames per scene, or scene count from 2–16 at a fixed duration of 10 s (60 latent frames). Scene lengths follow evenly spaced quantiles of a log-normal distribution with σ = 0.5. Each run uses three denoising steps without classifier-free guidance and reports the faster of the last two steps. We test NVLink and PCIe configurations. Equation 2 selects K/V gathering throughout, with communication–computation overlap enabled for the PCIe runs. Figure 18 shows that OneReel reduces communication volume by 1.5–6.2× relative to the oracle. For the fixed-length request, the oracle exchanges 96 GB per forward regardless of scene count, whereas OneReel’s traffic falls from 65 GB to 18 GB as the count increases from two to sixteen. More scenes allow the balanced partition to retain more

Speedup over db-SP oracle Traffic per forward (GB)

OneReel, NVLink

1.2

200

1.1

OneReel, PCIe

1.17×

Let B denote the effective all-to-all bandwidth and θB the effective K/V-gathering bandwidth, with θ ≈ 1.0 in our measurements. This bandwidth-based model excludes collective startup latency and overlap with computation.

5.2×

Ulysses-style execution. In the pure-Ulysses configuration of USP, each GPU initially holds L/P tokens across all heads. All-to-all redistributes Q, K, and V into head partitions and returns the attention output to the token partition. Each of these four tensors transfers a fraction (P − 1)/P of its local data, giving

db-SP oracle

1.10×

1.0 6.2× 4.9× 5.4×

100 2.4×

0

1.5×

2.2×

5.2×

1.9×

3

5 10 15 Request length (s)

20

2 4 8 16 Shots in a 10 s request

Figure 18: Comparison with the balanced USP oracle. Top: denoising-step speedup. Bottom: total communication per forward across both GPUs. Left: increasing video duration. Right: increasing scene count at a fixed duration of 10 s.

VU = 4 ·

4LD(P − 1) L P −1 . · ·D = P P P2

(6)

Query-partitioned gathering. Each GPU retains all heads of its assigned queries and outputs, exchanging only missing K/V. For every scene i with xp,i > 0, GPU p needs ρi L − xp,i remote tokens. The busiest GPU therefore receives X VG = 2D max (ρi L − xp,i ) . (7)

complete scenes locally, reducing remote K/V demand without changing the total video length. The latency benefit reaches 1.07× with NVLink, where Ring overlaps much of its communication with computation, and 1.17× with PCIe communication. The two-scene request remains near parity (0.99–1.00×): its longer scene contains 65% of the frames and must be split to balance computation, limiting the locality available to OneReel.

An intact scene contributes no intra-scene communication. Under the bandwidth-based model, gathering has lower communication time when VG /(θB) < VU /B, or equivalently VG < θVU , yielding Eq. 2.

E

E.2

C OMMUNICATION C OST OF K/V G ATHERING

This appendix derives the communication comparison in Eq. 2 and the scene-length condition in Eq. 4. We first consider scene-local video attention, then account for shared frames. E.1

Communication Model

A request contains L video tokens partitioned P into K scenes, with scene i containing ρi L tokens and i ρi = 1. Attention runs on P GPUs. Let D denote the bytes per token in one tensor across all heads, and let xp,i denote the number of scene i’s queries assigned to GPU p. Their P corresponding local K/V follow the same partition, so p xp,i = ρi L. Without shared frames, total attention work is proportional to X X (ρi L)2 = SL2 , S= ρ2i . (5) i

i

The derivation assumes an ideal work-balanced partition with workload SL2 /P per GPU. The implementation rounds partition boundaries to the supported frame granularity. We approximate communication time by the volume received by the busiest GPU divided by effective bandwidth.

p

i: xp,i >0

Lower Bound and Necessary Condition

Let ρmax = maxi ρi . Work balance limits how many queries of the longest scene can remain on one GPU, providing a lower bound on the K/V that gathering must transfer. Lemma E.1. Under an ideal work-balanced partition, each GPU holds at most SL/(P ρi ) queries of scene i. Proof. Each query of scene i attends to ρi L keys. The perGPU workload budget therefore gives xp,i ρi L ≤ SL2 /P , hence xp,i ≤ SL/(P ρi ). Proposition E.2. Under an ideal work-balanced partition,   S VG ≥ 2LD ρmax − . P ρmax Proof. If the right-hand side is non-positive, the bound is immediate. Otherwise, consider a longest scene j. Lemma E.1 gives xp,j ≤ SL/(P ρmax ) < ρmax L, so the scene must span multiple GPUs. Any GPU holding its queries must receive at least ρmax L − SL/(P ρmax ) of its tokens. Accounting for both K and V gives the bound. Combining this bound with VG < θVU gives   S 4LD(P − 1) 2LD ρmax − ≤ VG < θ . P ρmax P2

Dividing by 2LD yields the necessary condition in Eq. 4: ρmax −

S 2θ(P − 1) . < P ρmax P2

This condition depends only on scene lengths and the bandwidth ratio. It is necessary rather than sufficient because other split scenes can contribute additional traffic. The communication comparison therefore uses the volume of the actual partition. E.3

Complete Attention Scopes

With shared frames, partitioning uses the full per-query attention cost |Si | defined in Section 3.2. Ulysses still redistributes the full sequence across heads, so its communication volume remains Eq. 6. Gathering instead transfers the remote video K/V required by the scopes assigned to each GPU. Let Lp denote the video tokens whose K/V are locally owned by GPU p. The complete gathered volume is   [ VG = 2D max  Si  \ Lp . (8) p

i: xp,i >0

The union counts each remote token once per destination GPU, even when several local scenes read it. Copies subsequently created for per-scene packing do not incur additional inter-GPU traffic. Without shared frames, Eq. 8 reduces to Eq. 7. Equation 8 supplies the communication volume for the same bandwidth-based comparison. The closed-form necessary condition above characterizes scene-local attention, while complete-scope accounting includes the selected shared frames and the resulting workload partition.

F

I MPLEMENTATION D ETAILS

Model integration. OneReel uses PyTorch, xDiT (Fang et al., 2024), and model-specific attention processors without modifying pretrained weights. Scene prompts are encoded independently, and HunyuanVideo-1.5 also applies its text-token refiner separately to each prompt. Model adapters expose scene ranges and modality indices. Representative-frame selection. Frame features are spatially mean-pooled from the middle transformer block, synchronized through an all-reduce of per-frame sums and token counts, and normalized. We use spherical k-means with M = 4, farthest-point initialization, and at most 20 iterations. Each cluster selects the frame nearest its centroid, breaking ties by frame index. Selected indices apply at the next denoising step, while the initial step uses modelspecific boundary frames.

Request-level planning. Initial boundary scopes determine the query partition and communication path once per request. Path selection uses θ = 1.0, assuming equal effective bandwidths. The partition and path remain fixed throughout denoising, while representative updates change the shared-frame lists used for packing. Packed attention. OneReel batches query pieces using FlashAttention-3 variable-length attention. Each layer packs K/V from its current activations. Contiguous scopes are read directly using cu seqlens k and seqused k, avoiding copies when the required K/V already form a contiguous range. K/V and text-output exchange. The K/V-gathering path merges overlapping remote intervals and transfers them through batched NCCL point-to-point operations. Each remote token is received once per destination GPU. In this path, each scene’s text queries are computed by the GPU holding its first video token, which sends the outputs only to GPUs that need them. Communication overlap. In the PCIe configuration, NCCL peer-to-peer transport is disabled and transfers are staged through host memory. OneReel computes attention over local keys while remote K/V are transferred, then computes attention over the received keys and merges the partial outputs using log-sum-exp values. This split-attention path is disabled on NVLink.

Related documents

• SE-Mem: Semantic-Episodic Memory for Scene-Consistent Generative View Synthesis#1536484
• Mira-Scene: Pixel-Aligned Layouts for Generative 3D Scene#1054722
• Prism: Dynamic Sparse Attention for Native 2K Joint Video-Audio Generation Model Training#1221431
• Prism: Dynamic Sparse Attention for Native 2K Joint Video-Audio Generation Model Training#1201429
• Mira-Scene: Pixel-Aligned Layouts for Generative 3D Scene Reconstruction#1052299