HunyuanVideo 1.5 Technical Report

🎯 Pitch

An 8.3B-parameter open-source model matches or exceeds the quality of 27B-parameter proprietary systems while running on consumer GPUs, thanks to a novel attention mechanism that dynamically prunes redundant visual tokens during generation. This breakthrough is achieved through a Selective and Sliding Tile Attention design that combines block-wise importance scoring with sliding-window locality, yielding a 1.87× speedup over FlashAttention-3 while requiring only 13.6 GB of GPU memory for 720p video synthesis.

1. Executive Summary

HunyuanVideo 1.5 introduces a lightweight open-source video generation model that achieves state-of-the-art visual quality and motion coherence with only 8.3 billion parameters, enabling efficient inference on consumer-grade GPUs. The framework employs a unified Diffusion Transformer architecture supporting both text-to-video and image-to-video generation, followed by a cascaded video super-resolution network that upscales outputs to 1080p. The model's efficiency stems from a Selective and Sliding Tile Attention (SSTA) mechanism (dynamically pruning redundant spatiotemporal tokens by combining block-wise importance scoring with sliding window locality) and a causal 3D VAE achieving 16× spatial and 4× temporal compression, yielding an end-to-end speedup of 1.87× over FlashAttention-3 in 10-second 720p synthesis. In GSB evaluations against competitors including Wan2.2 and Kling2.1 Master, HunyuanVideo 1.5 achieves win rates of 17.12% for T2V and 12.65% for I2V over Wan2.2, while requiring only 13.6 GB peak GPU memory for 720p generation—establishing that compact DiT architectures augmented with sparse attention and progressive multi-stage training can rival proprietary systems, though only when paired with dedicated super-resolution post-processing to reach competitive visual fidelity.

2. Context and Motivation

The Core Problem: Open-Source Video Generation Lags Behind Proprietary Systems in Quality AND Efficiency

The fundamental gap this paper addresses is deceptively precise: there exists no open-source video generation model that simultaneously achieves state-of-the-art visual quality and consumer-grade inference efficiency. This is not simply a matter of open-source catching up to proprietary systems on quality alone—it's about achieving that quality without the massive computational overhead that has historically been the price of admission for high-fidelity video synthesis.

To understand why this gap is so significant, we need to look at the landscape as the paper sees it (Section 1). Three closed-source systems define the frontier: Kling2.5 (Kuaishou Technology, 2025), Veo3.1 (Google DeepMind, 2025), and Sora2 (OpenAI, 2025). These models produce videos of remarkable quality—strong motion coherence, precise instruction following, high aesthetic appeal—but they are black boxes. Researchers cannot study their architectures, can't fine-tune them for specialized domains, can't deploy them in privacy-sensitive contexts, and can't build on them as foundation models for downstream research.

On the open-source side, three models are cited as notable contenders: HunyuanVideo (the predecessor from the same team, 2025), StepVideo (Ma et al., 2025), and Wan2.2 (Wan et al., 2025). The paper positions Wan2.2 as the most direct comparison point—and the one whose shortcomings most clearly motivate HunyuanVideo 1.5's design choices. Understanding Wan2.2's architecture is essential to appreciating why the paper takes its particular approach.

Understanding the Wan2.2 Baseline and Why It Falls Short

Wan2.2 employs a hybrid Mixture of Experts (MoE) architecture that uses two separate 14-billion-parameter expert models specialized for different denoising stages (Section 1). The total parameter count is 27B, with 14B activated at any given time. This design philosophy—use specialized sub-models to handle different aspects of the generation process—is a natural way to boost quality, and it works: Wan2.2 achieves strong visual fidelity. But the paper identifies three specific, interlocking problems with this approach:

1. Computational inefficiency from managing multiple parameter sets. Even though only 14B parameters are active at a time, the system must store all 27B parameters and orchestrate the switching between expert models during inference. The paper states this explicitly: "this MoE architecture... inherently introduces computational inefficiencies, as the model must manage multiple large parameter sets... leading to significant resource demands." This is not just a memory issue—it's a complexity issue. The expert routing mechanism, the synchronization between denoising stages, and the overhead of loading/unloading expert weights all contribute to a system that is difficult to deploy outside datacenter-scale hardware.

2. The compact variant sacrifices too much capability. Wan2.2 attempted to address this with a 5-billion-parameter variant that uses a high-compression 3D VAE to reduce memory footprint. This is the obvious engineering response: if the 27B model is too heavy, compress more aggressively and shrink the model. But the paper argues this approach has fundamental limitations: "this lightweight model still exhibits limitations. Specifically, its generative capabilities, particularly in maintaining motion stability across frames and achieving the nuanced aesthetic quality required for professional applications, continue to fall short of practical demands."

Notice the specificity of the failures: motion stability across frames and nuanced aesthetic quality. These are not generic "lower quality" complaints—they point to specific artifacts that arise when you compress too much. High compression ratios in the VAE can discard fine spatiotemporal details that are essential for smooth motion and subtle visual textures. A smaller DiT with fewer parameters may lack the capacity to model complex motion patterns or to generate the kind of detailed, aesthetically pleasing outputs that users expect from "state-of-the-art" systems.

3. The underlying tension: quality versus accessibility is treated as a pure engineering tradeoff. Wan2.2's two-pronged approach (big MoE for quality, small compressed variant for accessibility) implicitly accepts that you must choose one or the other. The paper rejects this framing. The core bet of HunyuanVideo 1.5 is that this is a false dichotomy—that a carefully designed 8.3B-parameter model, with the right attention mechanism and training strategy, can achieve quality competitive with the 27B MoE while maintaining the inference efficiency of a compact model.

Why This Gap Matters: Beyond Academic Interest

The paper is not just solving an intellectual puzzle. The motivation is grounded in concrete, practical consequences of the current state of affairs:

Barrier to community-driven innovation. When the best video generation models are proprietary, the entire research ecosystem suffers. Academic labs cannot study failure modes, cannot propose architectural improvements, cannot adapt models to specific domains (medical imaging, scientific visualization, educational content), and cannot conduct the kind of systematic ablation studies that drive scientific understanding. The paper frames this explicitly: "most SOTA models remain proprietary, limiting accessibility and community-driven innovation." Releasing HunyuanVideo 1.5 as open-source (code and weights) is positioned as a direct intervention against this trend.

The deployment bottleneck for real-world applications. Video generation is not just about producing impressive demos. Real applications—content creation tools, game asset generation, video editing assistants, synthetic data generation for training computer vision models—require models that can run on hardware that practitioners actually have access to. The paper emphasizes that HunyuanVideo 1.5 can run on a single consumer-grade GPU (RTX 4090) with only 13.6 GB peak memory for 720p generation (Section 6). This is not a minor detail—it's the difference between a model that exists as a research artifact and one that can be integrated into products and workflows.

The bilingual and text-rendering gap. A subtler but important motivation: existing models (both open and closed) often struggle with non-English prompts and with generating legible text within videos. The paper specifically calls out "enhanced bilingual understanding through glyph-aware text encoding" as a key contribution. For a global audience—particularly Chinese-English bilingual users, which is a massive user base—this capability gap is a real barrier to adoption. The incorporation of Glyph-ByT5 (Liu et al., 2024) for dedicated glyph encoding and Qwen2.5-VL for multimodal understanding addresses a need that prior open-source models largely ignored.

Where Prior Approaches Fall Short: A Deeper Technical Diagnosis

The paper's critique of prior work goes beyond the MoE inefficiency argument. There are several more subtle technical shortcomings that the paper identifies or implies:

Full attention scales quadratically, and naive sparsification is insufficient. Standard transformer self-attention has $O(n^2)$ complexity in sequence length $n$ . For video, $n$ is enormous: a 720p video at 24 fps for 10 seconds, with 16× spatial and 4× temporal VAE compression, still produces a very long token sequence (roughly 121 frames × (720×1280)/(16×16) = 121 × 3600 = ~435,600 tokens for a single video). Computing full attention over this sequence is prohibitive. Prior work has explored sparse attention as a solution, but the paper argues that existing sparse attention methods tend to fall into one of two camps:

Static local window approaches (like sliding window attention) enforce a fixed sparsity pattern based solely on token proximity. This captures local dependencies well—adjacent frames and nearby spatial regions—but misses long-range dependencies that are semantically important, such as a character's hand motion affecting an object on the other side of the frame several seconds later.
Dynamic global selection approaches (like top-k attention) adaptively select which tokens to attend to based on similarity scores, but can be computationally expensive to compute and may select tokens that are redundant (multiple tokens representing the same static background region).

The paper's SSTA mechanism (Section 3.1, Algorithm 1) is designed to combine the benefits of both: a sliding window for guaranteed local attention, plus a selective mask that dynamically identifies the most important global tokens (scored by query-key similarity minus key-key redundancy) to include. This is not just a minor optimization—it's a principled attempt to solve the sparsity-quality tradeoff that prior sparse attention methods struggled with.

Progressive training strategies are underutilized for video. The paper's training approach (Section 4, Table 2) spans six pre-training stages from 256p T2I through 720p 24fps T2V/I2V, followed by post-training (CT, SFT, RLHF). This is not simply "train on more data." The progression is carefully structured: start with text-to-image at low resolution to establish semantic alignment, then progressively increase spatial resolution, temporal length, and frame rate while mixing T2I, T2V, and I2V tasks at a 1:6:3 ratio. The insight—which the paper attributes in part to prior work on flow matching sensitivity to sequence length (Esser et al., 2024)—is that naive training on all resolutions and durations simultaneously is unstable. The shift hyperparameter in flow matching must be carefully scheduled as token lengths change across stages. Prior video generation models often either trained at a single resolution or used less structured curriculum approaches, potentially leaving performance on the table.

Caption quality—specifically the richness-hallucination tradeoff—is a bottleneck for instruction following. The paper devotes significant attention to captioning (Section 2.2), and for good reason: the quality of text descriptions used during training directly determines how well the model follows prompts at inference time. The problem is that more detailed captions tend to hallucinate—describing objects or actions that aren't actually in the video—while conservative captions miss important details. The paper describes this as an "inherent trade-off between descriptive richness and factual accuracy" and addresses it with reinforcement learning (OPA-DPO, Yang et al., 2025) in the caption model post-training pipeline (Figure 1). This is a meta-problem: improving the model that generates training data for the video model.

Additionally, for image-to-video, the paper introduces a novel captioning module that specifically describes "temporal evolution or transformation from the initial frame, detailing changes in both foreground subjects and the background environment." This is necessary because standard video captions describe the entire clip holistically, but I2V training needs information about how the scene changes from the first frame. Without this, the model cannot learn to condition on a static image and generate appropriate motion.

Video super-resolution is treated as an afterthought in some pipelines. Many video generation models produce lower-resolution outputs and rely on generic upscaling methods (bicubic interpolation, off-the-shelf super-resolution networks trained on natural images) for final display. The paper argues this is insufficient: video-specific artifacts (temporal flickering, motion-adaptive detail, compression artifacts in low-res latents) require a dedicated video super-resolution network trained in the latent space. The cascaded VSR model (Section 3.2, Figure 3) is initialized from a pretrained T2V model and trained on 1M high-quality video clips from 1K to 4K resolution, with high-resolution images also mixed in to enhance fine detail generation. The key design choice—performing super-resolution in latent space rather than pixel space—means the VSR model can focus on detail enhancement without the full computational cost of pixel-space video processing.

How This Paper Positions Itself

The paper does not claim to invent video diffusion models, flow matching, or sparse attention. Its contribution is engineering synthesis: combining a specific set of design choices—compact DiT architecture (8.3B parameters, not 27B MoE), causal 3D VAE with aggressive but not extreme compression (16× spatial, 4× temporal), dual-stream text encoding (Qwen2.5-VL for semantics + Glyph-ByT5 for text rendering), SSTA sparse attention, Muon optimizer, progressive multi-stage training with balanced task mixing, dedicated video super-resolution, and a thorough post-training pipeline with RLHF—into a single model that achieves the quality-efficiency sweet spot the field has been missing.

The positioning relative to Wan2.2 is the most explicit. Table 5 shows HunyuanVideo 1.5 achieving a 17.12% win rate over Wan2.2 in T2V GSB evaluation, and Table 6 shows 12.65% for I2V. These numbers mean that when human evaluators compare outputs side-by-side, HunyuanVideo 1.5 is preferred to Wan2.2 substantially more often than the reverse. This is with an 8.3B model versus Wan2.2's 27B-total/14B-active MoE. The paper is making a strong claim: architectural efficiency matters more than raw parameter count for video generation.

Relative to proprietary systems (Kling2.1 Master, Seedance Pro, Veo3), the picture is more nuanced. In T2V GSB (Table 5), HunyuanVideo 1.5 has a negative win rate against Veo3 (-10.32%) but positive win rates against Kling2.1 Master (+12.6%) and Seedance Pro (+11.02%). In the Rating evaluation (Table 3), HunyuanVideo 1.5 leads on "Instruction following" (61.57 vs. 44.07–53.19 for competitors except Veo3 at 73.77) and "Structural stability" (79.75, the highest across all models), but trails on "Aesthetic quality" (63.30 vs. 65.98–68.22 for competitors). This is an honest positioning: the model excels at understanding and following instructions and maintaining structural consistency, but pure aesthetic quality still favors some proprietary systems. The paper does not claim to surpass Veo3 in overall quality—it claims to be competitive while being open-source and efficient enough for consumer GPUs.

A final, implicit positioning: the paper is a statement about the open-source research model itself. By releasing code, weights, and a detailed technical report with specific hyperparameters (Table 1: 54 dual-stream blocks, model dimension 2048, FFN dimension 8192, 16 attention heads, head dimension 128), the paper enables exact replication and extension. This is in stark contrast to proprietary systems that reveal essentially nothing about their internals. The motivation is not just about one model—it's about establishing that open-source video generation can be competitive at the frontier, which has downstream effects on the entire research ecosystem's ability to make progress.

3. Technical Approach

3.1 Reader Orientation

HunyuanVideo 1.5 is a two-stage video synthesis pipeline: a unified 8.3-billion-parameter Diffusion Transformer generates initial video sequences from text prompts or reference images, and a dedicated video super-resolution network then upscales these outputs to 1080p with enhanced visual detail. The system solves the problem of achieving state-of-the-art video generation quality while maintaining inference efficiency suitable for consumer-grade GPUs — it does this not through a single architectural breakthrough but through a carefully orchestrated combination of aggressive VAE compression, a novel sparse attention mechanism that dynamically prunes redundant spatiotemporal tokens, dual-channel bilingual text encoding, and progressive multi-stage training spanning from low-resolution text-to-image pretraining through task-specific RLHF post-training.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components connected in a pipeline, with two distinct stages of operation:

Stage 1: Unified Diffusion Transformer (DiT) — an 8.3B-parameter diffusion model that performs the core video generation. It takes three possible inputs depending on the task: a text prompt (for T2V), a text prompt plus a reference image (for I2V), or a text prompt alone for image generation (T2I). These inputs are encoded through separate pathways and combined into a unified representation that the DiT denoises in latent space.

Text Encoding (Dual-Channel) — two parallel text encoders process the input prompt: Qwen2.5-VL (a vision-language multimodal encoder) extracts high-level semantic understanding of scene descriptions, character actions, and requirements; Glyph-ByT5 (a character-level text encoder) captures fine-grained glyph and text-rendering information. The outputs are combined so the DiT receives both semantic and character-level text features.

Image Encoding (for I2V only) — the reference image enters through two complementary paths: (1) VAE-based encoding concatenates the image latent with the noisy video latent along the channel dimension, preserving fine visual detail; (2) SigLip-based feature extraction produces semantic embeddings that are concatenated sequentially to improve semantic alignment between the reference image and the generated motion. A learnable type embedding distinguishes between T2V, I2V, and T2I conditions.

Causal 3D VAE — a transformer-based autoencoder that compresses video into a compact latent representation (16× spatial, 4× temporal compression, latent channel dimension 32) before the DiT processes it, then decodes the DiT's output latents back to pixel space after generation. The "causal" property means temporal compression respects the arrow of time.

SSTA Sparse Attention (inside the DiT) — replaces full self-attention in the DiT's transformer blocks with an efficient block-sparse pattern that combines a sliding window (for guaranteed local spatiotemporal attention) with a dynamic selection mask (for global attention to the most important tokens, computed from query-key similarity minus key-key redundancy). This is parameter-free and can be integrated at any training stage.

Stage 2: Video Super-Resolution Network — a separate diffusion model initialized from a pretrained T2V checkpoint that upscales the Stage 1 output to 1080p. It operates entirely in latent space (receiving the low-resolution latent and noise concatenated along the channel dimension as input) and is trained on 1M high-quality video clips from 1K to 4K resolution plus high-resolution static images. The final decoded output is the production-quality 1080p video.

Information flow: Text prompt → dual text encoders → combined text features. [If I2V: reference image → VAE encoding + SigLip encoding → combined image features]. Text features [and image features] condition the DiT. Random noise is sampled in latent space. The DiT iteratively denoises over 50 steps (using flow matching), producing a clean video latent. The VAE decoder converts this to a 480p–720p pixel-space video. The VSR network takes this low-resolution video (encoded back to latents) plus noise, performs additional diffusion steps, and outputs refined latents. The VAE decoder produces the final 1080p video.

3.3 Roadmap for the Deep Dive

First, the Unified DiT architecture and its multi-task training mechanism — because this is the core generative engine and all other components (text encoding, SSTA, VAE) interface with it.
Second, the Causal 3D VAE — because understanding the compression ratios and latent space is essential for grasping why the DiT operates at the scale it does and how SSTA's impact on sequence length translates to real speedups.
Third, the dual-channel text encoding system — because the choice to combine Qwen2.5-VL and Glyph-ByT5 is a key differentiator for bilingual understanding and text rendering, and the encoding pathway directly determines what signals the DiT receives as conditioning.
Fourth, the SSTA sparse attention mechanism — because it is the primary efficiency innovation and requires understanding the block partition, selective scoring, and mask combination logic before we can evaluate its speedup claims.
Fifth, the video super-resolution network — because it is the second stage of the pipeline and understanding its latent-space design and training data clarifies how the system achieves 1080p quality without running the full DiT at that resolution.
Sixth, the training methodology (progressive pre-training + post-training) — because the staged curriculum, task mixing ratios, optimizer choice (Muon), and RLHF pipeline explain how the components are trained and why the reported quality metrics are achieved.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and engineering paper whose core idea is that an 8.3B-parameter DiT augmented with selective sparse attention, dual-channel bilingual text encoding, and progressive multi-stage training can match or exceed the quality of much larger MoE-based open-source models while maintaining consumer-GPU inference efficiency — and that open-sourcing such a model advances the field more than incremental proprietary improvements.

Unified Diffusion Transformer Architecture and Multi-Task Training

The DiT is the central generative model. It is a dual-stream block design with 54 transformer blocks, a model dimension of 2048, an FFN dimension of 8192, 16 attention heads, and a head dimension of 128 (Table 1). "Dual-stream" means the model processes two parallel information streams — one for the spatial (and spatiotemporal) features of the video latent, and one for the conditioning text (and optionally image) features — which interact through cross-attention and/or concatenation at each block.

The DiT is trained as a unified multi-task model handling text-to-image (T2I), text-to-video (T2V), and image-to-video (I2V) generation. This is not three separate models or three separate heads on a shared backbone — it is a single architecture that receives different conditioning signals depending on the task and learns to interpret them appropriately. The unification is achieved through three mechanisms:

1. Channel-dimension concatenation for I2V reference images (VAE-based encoding). For the I2V task, the reference image is first encoded into a latent representation using the same VAE that encodes video frames. This image latent is then concatenated with the noisy video latent along the channel dimension before being fed into the DiT. Concretely, if the noisy video latent has shape [B, C, T, H, W] (batch, channels, frames, height, width), the image latent is expanded to match the temporal dimension (repeated across all frames) and concatenated, producing a tensor of shape [B, 2C, T, H, W]. The DiT's first layer is adapted to accept this doubled channel count.

Channel-dimension concatenation is chosen because it preserves the spatial structure of the reference image latent at full resolution. The DiT's convolutional and attention operations can directly compare the reference image features with the generated video features at every spatial location, enabling precise detail transfer. This is particularly important for maintaining the identity of objects, textures, and backgrounds from the reference image — if the reference were instead compressed into a 1D embedding vector (as in some prior approaches), fine spatial details would be lost.

2. Sequential concatenation for I2V semantic features (SigLip-based encoding). In parallel with the VAE encoding, the reference image is also processed through a SigLip vision encoder, which produces a set of semantic feature vectors (a sequence of embeddings, not a single pooled vector). These semantic embeddings are concatenated sequentially — that is, appended to the sequence of text-conditioning tokens that the DiT's cross-attention layers attend to. If the text encoder produces $T$ tokens and SigLip produces $S$ image tokens, the conditioning sequence becomes $T + S$ tokens long.

This approach gives the DiT's cross-attention mechanism direct access to semantic-level image features at every generation step and every spatial location in the video latent. The model can learn to attend to specific image regions (e.g., "this is what the subject's face looks like") when generating corresponding video regions. Sequential concatenation is chosen over alternative fusion methods (such as element-wise addition or a separate cross-attention pathway) because it reuses the existing cross-attention infrastructure and allows the model to learn flexible alignment between text tokens, image tokens, and video latent tokens.

3. Learnable type embeddings for task disambiguation. To help the DiT distinguish between T2I, T2V, and I2V generation — which have fundamentally different input structures and expected output behaviors — a learnable type embedding is introduced. This is a small learned vector (or set of vectors) that is added to or concatenated with the conditioning input, encoding which task is being performed. The exact mechanism (addition vs. concatenation) is not fully specified in the report, but the principle is standard in multi-task transformer architectures: the type embedding acts as a "task identifier" that the model can learn to use as a gating signal, activating different internal pathways for different generation modes.

The DiT operates in flow matching paradigm rather than standard diffusion. Flow matching (also called rectified flow) defines a continuous transformation between the data distribution and a simple prior (Gaussian noise) along straight-line paths. At training time, the model learns to predict the velocity field that moves samples from noise to data. At inference time, starting from random noise, the model's predicted velocity is integrated over time (using an ODE solver or a hybrid ODE-SDE solver like MixGRPO, as described in Section 4.2) to produce a clean latent. The paper notes (Section 4.1) that flow matching is "particularly sensitive to the shift hyper-parameter when video token lengths vary across stages," necessitating careful shift scheduling during progressive training.

Causal 3D VAE

The VAE (Variational Autoencoder) is the bridge between pixel space and latent space. Its job is to compress raw video frames into a compact representation that the DiT can process efficiently, and then decode the DiT's output back to pixel space without introducing visible artifacts. The paper introduces a causal 3D transformer architecture for this VAE, with specific compression ratios and a causal temporal design.

Compression ratios. The VAE achieves 16× spatial compression and 4× temporal compression, with a latent channel dimension of 32. This means that if the input is a video of resolution $H \times W$ with $F$ frames and 3 color channels, the latent has shape:

Spatial: $H/16 \times W/16$
Temporal: $F/4$ frames
Channels: 32

For a concrete example: a 720p (720 × 1280) video with 121 frames becomes a latent of shape [32, 121/4, 720/16, 1280/16] = [32, ~30, 45, 80]. The total number of tokens (treating each spatial position in each temporal frame as a token) is approximately $30 \times 45 \times 80 = 108,000$ tokens. This is the sequence length that the DiT's attention must process. Without this compression, full-resolution pixels would yield millions of tokens, making attention completely infeasible.

The choice of 16× spatial is aggressive but not extreme — many image generation models use 8× compression (e.g., Stable Diffusion), so 16× means 4× fewer spatial tokens for the same resolution. The 4× temporal compression means that for 24 fps video, the latent operates at an effective 6 fps temporal resolution. This is sufficient to capture most human-visible motion while dramatically reducing sequence length.

Causal 3D design. The "causal" property means that when encoding frame $t$ , the VAE can only attend to frames $0, 1, ..., t-1$ (past frames), not future frames. This is implemented through causal masking in the temporal attention layers. The motivation is twofold: (1) it makes the VAE consistent with the autoregressive nature of video playback (you can't see the future), which may improve temporal coherence in generated videos; (2) it enables efficient inference where the VAE can encode/decode one frame at a time without needing the full video upfront, which is important for streaming and real-time applications. The 3D aspect means the transformer operates on spatiotemporal patches — groups of pixels across space and time — rather than treating frames independently.

Joint image-video encoding. The VAE is designed to encode both images and videos in a unified architecture. For images (single frames), the temporal dimension simply has size 1, and the temporal compression becomes a no-op (or applies standard 2D operations). This unified design means the DiT can use the same VAE for T2I, T2V, and I2V tasks without any modality switching, and the compressed representations live in a shared latent space.

Why a transformer VAE over convolutional? The paper does not elaborate extensively on this choice, but the rationale is consistent with trends in video generation: 3D convolutional VAEs can suffer from temporal artifacts (flickering between frames) because convolutions with limited temporal kernels cannot model long-range temporal dependencies. A transformer can attend across the entire temporal span (or a large window), potentially producing more temporally consistent latents. The tradeoff is computational cost, but since the VAE is only run once per video (encoding before DiT, decoding after), the cost is amortized.

Dual-Channel Text Encoding

The text encoding system is responsible for converting arbitrary natural language prompts (in Chinese, English, or mixed) into conditioning signals that the DiT can use to guide generation. The paper uses a dual-channel design: two separate encoders that process the same text input in parallel, producing complementary features that are combined before being fed to the DiT.

Channel 1: Qwen2.5-VL (multimodal semantic encoder). Qwen2.5-VL is a vision-language model (Bai et al., 2025) that has been pretrained on large-scale image-text and video-text pairs. It understands not just the literal words in a prompt but also their visual implications — for example, "a golden retriever playing in a sunny park" activates representations that capture the appearance of the dog breed, the lighting conditions, the spatial layout of a park scene, and the action semantics of "playing." The paper states this encoder provides "deeper understanding of scene descriptions, character actions, and specific requirements."

Qwen2.5-VL is a transformer-based model that processes text through its language model component, producing a sequence of hidden states (one per input token). These hidden states are used as the conditioning signal for the DiT's cross-attention layers. Because Qwen2.5-VL was trained on multimodal data, these representations naturally encode visual-semantic associations even though the model is only receiving text at inference time (for T2V).

Channel 2: Glyph-ByT5 (glyph-aware character encoder). Glyph-ByT5 (Liu et al., 2024) is a specialized text encoder designed specifically for accurate visual text rendering — generating legible, correctly spelled text within images and videos. Standard text encoders (including most LLMs) operate at the subword or word level, processing "hello" as a single token or at most a few tokens. This makes it extremely difficult for a generative model to produce pixel-accurate renderings of that word, because the spelling information is lost in the tokenization.

Glyph-ByT5 operates at the character level — it processes text as sequences of individual Unicode characters, encoding each character's visual glyph information (its shape, stroke order, spatial layout). This gives the DiT access to fine-grained character-level features that enable it to render text accurately in generated videos. The paper specifically highlights "multilingual" Glyph-ByT5, meaning it supports both Chinese characters and Latin script, essential for bilingual Chinese-English generation.

How the channels combine. The paper states this is a "synergistic design" where the DiT "learns from both high-level semantic representations and fine-grained language-specific features." The exact combination mechanism is not fully specified, but the standard approach in dual-encoder designs is to either (1) concatenate the token sequences from both encoders along the sequence dimension, or (2) fuse the features through a learned projection layer that combines them into a single conditioning sequence. Either way, the DiT's cross-attention layers can attend to both the semantic Qwen2.5-VL tokens (for understanding what to generate) and the glyph-aware ByT5 tokens (for knowing how to render any text that appears).

Why a dual-channel design over a single multilingual encoder? The paper does not explicitly compare against a single-encoder baseline, but the rationale is clear from the capabilities being targeted: general visual-semantic understanding and accurate text rendering are fundamentally different tasks that benefit from different pretraining objectives and architectures. A single VL model, no matter how large, may struggle to maintain character-level glyph awareness because its training objective (typically next-token prediction on multimodal data) does not explicitly reward preserving spelling information. Conversely, a pure glyph encoder would lack the rich visual-semantic knowledge needed for scene understanding. The dual-channel design is a pragmatic decomposition: let each encoder do what it's best at, and let the DiT learn to integrate them.

SSTA: Selective and Sliding Tile Attention

SSTA is the primary efficiency innovation in HunyuanVideo 1.5, achieving an end-to-end speedup of 1.87× over FlashAttention-3 on 10-second 720p synthesis. It replaces the DiT's standard full self-attention with a block-sparse pattern that combines static locality and dynamic importance. The mechanism is parameter-free (no learned weights for the sparsity pattern) and can be integrated at any training stage — in the paper's implementation, it is incorporated during the distillation phase, "which more effectively preserves output quality while maintaining high computational efficiency."

The problem SSTA solves is fundamental to video transformers: the quadratic cost of attention. Standard self-attention computes:

$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$

where $Q, K, V \in \mathbb{R}^{h \times F \times H \times W \times d}$ are the query, key, and value tensors, $h$ is the number of attention heads, $F \times H \times W$ is the spatiotemporal sequence length (frames × height × width), and $d$ is the head dimension.

What it computes: For every one of the $F \times H \times W$ query positions (each representing a specific spatial location at a specific frame), the model computes a dot-product similarity with every key position (all spatial locations across all frames), producing an attention matrix of size $(FHW)^2$ . This matrix is then used to weight the value vectors, producing an output for each query position.

Why this is a problem: If $F = 30$ (after 4× temporal compression) and $H \times W = 45 \times 80 = 3600$ (after 16× spatial compression), the sequence length is $30 \times 3600 = 108,000$ . The attention matrix has $108,000^2 \approx 11.7$ billion entries — per attention head, per transformer block, per diffusion step. With 16 heads and 54 blocks and 50 diffusion steps, this is completely infeasible. Full attention must be replaced with something more efficient that preserves output quality.

SSTA reduces this cost through block-sparse attention combined with mask generation. Algorithm 1 describes four sequential steps:

Step 1: 3D Block Partition

The query and key tensors $\in \mathbb{R}^{h \times F \times H \times W \times d}$ are partitioned into 3D blocks of size $N = \text{tile}_t \times \text{tile}_h \times \text{tile}_w$ , where $\text{tile}_t$ , $\text{tile}_h$ , and $\text{tile}_w$ are the temporal, height, and width tile sizes respectively. The total number of blocks is:

$B = (F / \text{tile}_t) \times (H / \text{tile}_h) \times (W / \text{tile}_w)$

where $B$ is the number of blocks across all spatiotemporal dimensions.

What it computes: Rather than working with individual tokens, SSTA groups tokens into contiguous spatiotemporal blocks (e.g., a 4×4×4 cube of tokens across time, height, and width). All tokens within a block are treated as a unit for the purpose of deciding which blocks attend to which other blocks. Within attended-to blocks, full attention is still computed, so there is no information loss within a block — the sparsity is at the inter-block level only.

Why block-level sparsity: Attending to individual selected tokens would require gathering scattered memory locations, which is extremely inefficient on GPUs. By selecting entire contiguous blocks, the attention computation can use efficient block-sparse matrix multiplication kernels (the flex_block_attention operation in line 21). The block size $N$ controls the granularity of the sparsity: larger blocks mean coarser sparsity but better hardware utilization.

Step 2: Selective Mask Generation

This step determines which blocks are important enough to attend to globally, beyond the local window. It computes a block importance score that combines two signals:

First, block-level query-key similarity is computed:

$\text{Score}_{s} = \bar{Q}_b \bar{K}_b^\top \in \mathbb{R}^{h \times B \times B}$

where $\bar{Q}_b$ is the pooled (average) query representation for each block, $\bar{K}_b$ is the pooled key representation for each block, and $\text{Score}_s$ is the block-wise similarity matrix.

Second, block-level key-key redundancy is computed:

$\text{Score}_{r} = \frac{1}{N-1} \sum_{\substack{i=1 \\ j \neq i}}^{N} [\bar{K}_b \bar{K}_b^\top]_{ij} \in \mathbb{R}^{h \times 1 \times B}$

where $\text{Score}_r$ measures how redundant each key block is — how similar it is to all other key blocks on average. A high redundancy score means the block contains information that is already well-represented by other blocks.

Then, the final block importance score is:

$\text{Score}_{i} = \lambda \cdot \text{Score}_{s} - \beta \cdot \text{Score}_{r}$

where $\lambda$ and $\beta$ are weighting hyperparameters that control the trade-off between similarity and redundancy.

What it computes: The importance score $\text{Score}_i$ is a scalar per key block (per attention head) that indicates how useful it is to attend to that block from the current query's perspective. The first term ( $\lambda \cdot \text{Score}_s$ ) positively weights blocks whose keys are similar to the query — these are likely to contain relevant information. The second term ( $- \beta \cdot \text{Score}_r$ ) penalizes blocks whose information is redundant with other blocks — attending to 50 nearly-identical background blocks wastes compute without adding information.

Why subtract redundancy: This is a key insight. Standard top-k sparse attention selects the k blocks with the highest query-key similarity scores, but this can result in selecting many redundant blocks (e.g., 20 blocks all showing the same static sky region). By subtracting a redundancy penalty, SSTA encourages selecting a diverse set of blocks that collectively cover different information. This is conceptually similar to maximizing mutual information or applying a determinantal point process to the selection — it promotes coverage of the visual scene rather than concentration on the most similar region.

Finally, a top-k selection is applied:

$\text{Selected\_indexes} \leftarrow \text{Topk}(\text{Score}_i, k)$

$\text{M}_{\text{sel}} \leftarrow \text{Indexes2mask}(\text{Selected\_indexes})$

where $\text{M}_{\text{sel}} \in \mathbb{R}^{h \times B \times B}$ is the selective attention mask, with $\text{M}_{\text{sel}}[i, j] = 1$ if block $j$ is selected for query block $i$ (in head $h$ ), and 0 otherwise.

Why head-specific selection: The selection is performed per attention head ( $\text{M}_{\text{sel}} \in \mathbb{R}^{h \times B \times B}$ ), meaning different heads can select different key blocks. This is crucial because different attention heads specialize in different aspects of the input (some might focus on motion, others on object identity, others on text). Allowing each head its own sparse pattern preserves this specialization.

Step 3: STA (Sliding Tile Attention) Mask Generation

In parallel with the selective mask, a static sliding window mask is generated:

$\text{M}_{\text{sta}}[i, j] = \begin{cases} 1 & \text{if block } j \text{ is within the local window of block } i \text{ defined by } \text{WS} = (w_t, w_h, w_w) \\ 0 & \text{otherwise} \end{cases}$

where $\text{M}_{\text{sta}} \in \mathbb{R}^{B \times B}$ is the sliding tile attention mask, and $(w_t, w_h, w_w)$ is the window size in temporal, height, and width dimensions.

What it computes: For each query block $i$ , a fixed window of neighboring blocks in the spatiotemporal grid is forced to be attended to. The window is defined by proximity in 3D space: blocks within $\pm w_t/2$ in the temporal dimension, $\pm w_h/2$ in height, and $\pm w_w/2$ in width. All blocks inside this window get $\text{M}_{\text{sta}}[i, j] = 1$ .

Why a static window is necessary: The selective mask alone, being top-k based, might miss blocks that are crucial for local coherence but happen to have low similarity scores (e.g., a boundary region between two objects might not be highly similar to either, but attending to it is essential for smooth transitions). The sliding window guarantees that every block attends to its immediate spatiotemporal neighborhood, which captures the local dependencies that are the backbone of coherent video generation. This is essentially a safety net: selective attention provides global context, sliding window provides guaranteed local context.

Why block-level (tile-level) windows: Standard sliding window attention (e.g., in language models) operates at the token level, attending to the previous $w$ tokens. For 3D spatiotemporal data, a token-level window is awkward because tokens are arranged on a 3D grid and proximity in token-index space doesn't correspond to spatial/temporal proximity. Tiling groups tokens into spatial blocks first, then applies the window at the block level, which naturally respects the 3D structure.

Step 4: Combine Masks and Block-Sparse Attention

The final combined mask is the logical AND of the selective and sliding window masks:

$\text{M}_{\text{combined}} \leftarrow \text{M}_{\text{sel}} \land \text{M}_{\text{sta}}$

where $\text{M}_{\text{combined}} \in \mathbb{R}^{h \times B \times B}$ , broadcast such that the head-specific $\text{M}_{\text{sel}}$ and the head-agnostic $\text{M}_{\text{sta}}$ are combined per head.

What the AND operation means: A key block $j$ is attended to by query block $i$ in head $h$ if AND ONLY IF it satisfies BOTH conditions: (1) it is within the sliding window of block $i$ , AND (2) it is among the top-k selected blocks for head $h$ . This might seem overly restrictive — what if an important block is far away (not in the window) but has high similarity? The answer is in the implementation: in practice, the selective mask and sliding window mask may not be combined with a strict AND; rather, the union or a weighted combination may be used. The paper's Algorithm 1 specifies $\land$ (AND), but the text in Section 3.1 states SSTA "synergistically combines the benefits of static local window priors and dynamic global adaptive selection," suggesting a less restrictive combination in practice. The exact configuration (AND vs. OR vs. weighted sum) is not fully specified and may be a hyperparameter.

Finally, block-sparse attention is computed using flex_block_attention:

$O \leftarrow \text{flex\_block\_attention}(Q, K, V, M_{\text{combined}})$

where $O \in \mathbb{R}^{h \times F \times H \times W \times d}$ is the output.

What flex_block_attention does: This is a custom CUDA kernel (released as flex-block-attn by Peng et al., 2025) built on the ThunderKittens framework (Spector et al., 2024). It takes the full Q, K, V tensors and the combined mask, and computes attention only for the non-zero entries of the mask. For each query block, only the attended-to key and value blocks are loaded from memory, the dot products are computed, softmax is applied over the attended (not all) keys, and the weighted sum is produced. This achieves substantial memory bandwidth savings because the vast majority of the K, V tensors are never accessed for each query.

Parameter-free design and integration. SSTA has no learned parameters — the masks are computed entirely from Q and K statistics at inference time. This means it can be integrated at any training stage without modifying the model architecture or requiring retraining. The paper integrates it during the distillation phase (a post-training stage where a smaller or optimized model learns to match a larger teacher), which "more effectively preserves output quality while maintaining high computational efficiency." The intuition is that if you apply SSTA from the beginning of training, the model may learn to rely on the specific sparse patterns and fail to develop robust full-attention representations; applying it later, after the model has already learned good representations, allows it to adapt to the sparsity without quality degradation.

Speedup analysis (Tables 7 and 8). Without engineering acceleration (Table 7), SSTA reduces per-step time from $5.5070 \pm 0.0284$ seconds to $2.9475 \pm 0.0206$ seconds for 241-frame 720p synthesis — a $1.87\times$ speedup. With engineering acceleration (Table 8: SageAttention, torch.compile, feature caching), the 50-step total time drops from 96.78 seconds to 58.39 seconds — a $1.66\times$ additional speedup from SSTA on top of engineering optimizations. This demonstrates that SSTA's benefits are additive, not redundant, with standard acceleration techniques.

Video Super-Resolution Network

The Video Super-Resolution (VSR) network is the second stage of the pipeline, responsible for upscaling the DiT's output from 480p or 720p to 1080p. It is not a generic upscaler — it is a specialized diffusion model designed to enhance video-specific qualities (sharpness, temporal consistency, texture detail) while correcting compression artifacts from the VAE and DiT pipeline.

Architecture. The VSR model is architecturally identical to the main DiT — a Video Diffusion Transformer with the same dual-stream block design — but initialized from a pretrained T2V checkpoint rather than trained from scratch. This weight initialization provides the VSR with strong priors about natural video structure, significantly reducing the amount of high-resolution training data needed.

Latent-space operation. The VSR operates entirely in the VAE's latent space, not in pixel space. The low-resolution (LR) input video — which has already been through the full T2V or I2V generation pipeline and VAE decoding — is first re-encoded into latent space using the same VAE encoder. The LR latent is then concatenated with the noise latent along the channel dimension, similar to how the reference image is concatenated for I2V in the main DiT. Specifically, if the LR latent has shape $[32, F/4, H_l/16, W_l/16]$ and the HR noise has shape $[32, F/4, H_h/16, W_h/16]$ (where $H_h, W_h$ are the high-resolution dimensions), the LR latent is upsampled to match the HR spatial dimensions using a separately trained latent upsample block, then concatenated to produce input $[64, F/4, H_h/16, W_h/16]$ .

Why latent space: Pixel-space super-resolution for video is extremely expensive — a 1080p video with 121 frames and 3 color channels has $121 \times 1080 \times 1920 \times 3 \approx 752$ million pixel values. Processing this through a diffusion model with repeated denoising steps would be prohibitive. By operating in latent space with 16× spatial compression, the effective spatial resolution is only 1080/16 = 67.5 and 1920/16 = 120, yielding approximately 2.9 million latent values per frame — a 256× reduction.

Training data. The VSR is trained on a curated dataset of 1 million high-quality video clips spanning resolutions from 1K to 4K at 24 fps, each 3–10 seconds long. Additionally, high-resolution static images are mixed into the training data "to enhance the model's capability to generate fine visual details." This is a clever trick: static images provide unlimited high-resolution detail for the model to learn from, and by training jointly on videos and images, the VSR learns to apply image-quality detail enhancement to every frame while maintaining temporal consistency (which the video data teaches).

Training objective. The VSR is trained using the same flow matching paradigm as the main DiT. All weights are fully trainable (no frozen components). The model learns to denoise the HR latent conditioned on the LR latent, text prompt, and (for I2V) reference image.

Visual impact (Figure 5). The paper shows qualitative results demonstrating that the VSR "significantly enhances visual quality, motion stability, and overall temporal coherence." The key improvements over the base output are sharper textures, reduced compression artifacts (blockiness, blurring), better-defined edges, and more natural fine details.

The "480pSR" configuration (Table 4). For I2V evaluation, the paper reports two HunyuanVideo 1.5 configurations: "HY1.5 480pSR" (generate at 480p, then super-resolve to 720p) and "HY1.5 720p" (generate directly at 720p). The 480pSR variant achieves an "Instruction following" score of 63.11 (vs. 63.05 for direct 720p), "Image consistency" of 68.82 (vs. 72.07), "Visual quality" of 59.87 (vs. 60.33), "Structural stability" of 70.13 (vs. 66.67), and "Motion effects" of 57.60 (vs. 58.62). The fact that 480pSR is competitive with direct 720p generation suggests the VSR effectively recovers quality, enabling a practical deployment strategy where the more expensive 720p generation is avoided in favor of cheaper 480p generation + super-resolution.

Training Methodology: Progressive Multi-Stage Pre-Training and Post-Training

The training of HunyuanVideo 1.5 follows a carefully structured curriculum spanning eight stages (Table 2), divided into pre-training (Stages I–VI) and post-training (Stages VII–VIII for CT, plus SFT and RLHF). This section covers the mechanics, rationale, and specific configurations of each phase.

Pre-Training Stages (I–VI): Building Foundational Capabilities

Stage I: T2I at 256p. Training begins with text-to-image generation at 256p resolution using 5 billion images curated from a pool of over 10 billion (Section 2.1). This stage establishes robust text-image semantic alignment — the model learns to map language descriptions to visual concepts. The paper explains the rationale: "The T2I task enables the model to learn robust semantic alignment between text and images, which we find significantly accelerates the convergence and performance of subsequent T2V & I2V training."

Why start with images: Images are far more abundant than videos, and image-text alignment is a simpler learning problem than video-text alignment (no motion to model). By first mastering the static visual-semantic mapping, the model develops strong visual priors that transfer to the temporal domain. This is a well-established strategy in video generation (used by Make-A-Video, Imagen Video, and others).

Stage II: T2I at 512p. The model continues T2I training at 512p resolution with 1 billion images. This upscaling step teaches the model to handle higher spatial resolutions while refining the text-image alignment learned at 256p.

Why a separate 256p and 512p stage: Directly training at 512p from scratch would be less stable and slower to converge. The progressive resolution increase allows the model to first learn coarse visual structure at low resolution (where training is fast) and then refine details at higher resolution.

Stages III–VI: T2V and I2V with mixed-task training. Starting at Stage III, the model transitions to video generation while maintaining T2I training to prevent catastrophic forgetting of image-level visual knowledge. The task ratio is 1:6:3 for T2I:T2V:I2V — meaning for every 10 training samples, 1 is T2I, 6 are T2V, and 3 are I2V. This ratio is chosen empirically to balance the competing demands: T2I data provides diverse visual concepts and helps maintain image quality, while the majority video data (T2V + I2V) drives video-specific learning.

Progressive spatiotemporal scaling across Stages III–VI:

Stage	Resolution	Frame Rate	Duration	Data Volume (video)
III	256p	16 fps	2–10s	800M
IV	480p	16 fps	2–10s	200M
V	720p	16 fps	2–10s	100M
VI	720p	24 fps	2–10s	100M

Why this specific progression: Spatial resolution, temporal resolution (frame rate), and duration are all increased gradually rather than simultaneously. Stage III at 256p/16fps is relatively low-dimensional, allowing the model to first learn basic temporal dynamics (how objects move, how scenes change) without the complexity of high-resolution detail. Stage IV and V increase spatial resolution while keeping the frame rate fixed, teaching the model to generate detailed frames while maintaining the motion patterns learned at 256p. Stage VI increases the frame rate from 16 to 24 fps, which demands more precise temporal modeling (motion must be smooth across 50% more frames) but leverages the high spatial quality already learned.

Data volume decreases as resolution increases. Note that the number of training samples decreases from 800M (256p) to 200M (480p) to 100M (720p). This is typical for progressive training: higher resolutions are more expensive per sample, and the model needs fewer examples to adapt to higher resolution once low-resolution foundations are solid. It also reflects practical data curation constraints — there are fewer ultra-high-quality 720p+ videos than 256p-level videos.

Flow matching shift scheduling. The paper notes (Section 4.1) that "flow matching-based training is particularly sensitive to the shift hyper-parameter when video token lengths vary across stages." In flow matching, the "shift" parameter controls the shape of the probability path between noise and data — specifically, how much the intermediate distributions are shifted toward the data distribution. As token lengths change across stages (longer videos = more tokens), the optimal shift changes. The authors "carefully design a series of shift scheduling strategies that adapt to different token lengths during the progressive training process." The exact scheduling function is not specified, but the principle is clear: the shift is not a fixed constant but a function of the sequence length, ensuring stable training across stages with vastly different token counts.

Muon optimizer. The paper uses the Muon optimizer (from the Kimi K2 model, Team et al., 2025) instead of the standard AdamW. The paper claims Muon "attains a lower training loss than AdamW in only half the number of training steps, while also yielding superior performance across multiple text-to-image benchmarks." A weight decay of 0.01 is applied for training stability.

Why Muon: The paper does not elaborate on Muon's mechanism, but it is a recently proposed optimizer that applies matrix orthogonalization to the gradient updates, maintaining approximate orthogonality of weight matrices during training. This has been shown to accelerate convergence in transformer training, particularly for large models. For a video generation model with 8.3B parameters trained across six stages with billions of samples, halving the number of training steps is a substantial practical benefit.

Post-Training Stages: CT, SFT, and RLHF

After pre-training establishes core generative capabilities, post-training refines the model for higher quality and better alignment with human preferences. This is done separately for T2V and I2V, as the tasks have different quality criteria.

CT (Continuing Training): Stages VII and VIII. Each task receives 1 million high-quality video clips for continued training at 480p and 720p resolution at 24 fps. For T2V CT, the paper specifically "prioritizes clips with high dynamic motion to strengthen temporal modeling" — the idea being that static or slow-motion videos don't provide useful training signal for the dynamics the model needs to learn. For I2V CT, "instructional captions that focus exclusively on describing motion and transformations compared to the first frame" are introduced — this is the novel I2V captioning module described in Section 2.2, which generates text specifically describing how the scene should evolve from the reference image.

Both CT processes are initialized from the same optimally pre-trained checkpoint, meaning the model at the end of Stage VI serves as the starting point for both T2V and I2V specialization. This shared initialization is possible because the pre-trained model already handles both tasks (through the multi-task training with 1:6:3 ratio), and CT simply fine-tunes the balance and quality.

SFT (Supervised Fine-Tuning). During SFT, the training data is further restricted to "rigorously selected clips per task, filtered strictly considering aesthetic appeal, clarity, and motion smoothness." This is a quality-over-quantity phase: by training only on the highest-quality examples, the model's output distribution shifts toward higher-quality generations. The paper reports "evident improvements in output stability, visual quality, aesthetic appeal, and temporal consistency" from CT and SFT.

RLHF for I2V. The I2V RLHF process employs online reinforcement learning to correct structural and motion artifacts. The key components are:

Prompt curation: A set of prompts spanning 100+ categories is constructed from high-aesthetic images. Candidate prompts are first generated by a VLM (vision-language model) to describe the images, then manually verified for text-image consistency. This ensures the RL training prompts are both diverse and accurate.

Reward model: A VLM-based reward model is fine-tuned to evaluate generated videos across four dimensions: text alignment (does the video match the text prompt?), image alignment (does the video respect the reference image?), visual quality (are there artifacts, blurring, distortion?), and motion dynamics (is the motion natural and physically plausible?).

RL training: A hybrid ODE-SDE solver called MixGRPO (Li et al., 2025) is used during RL training. Standard RL for diffusion models typically uses either an ODE solver (deterministic, fast, but limited exploration) or an SDE solver (stochastic, better exploration, but noisier samples). MixGRPO combines both by interleaving ODE and SDE steps, "enriching exploration while maintaining sampling quality." Mixed sampling strategies are also employed by varying random seeds and CFG (classifier-free guidance) scales during training to increase diversity.

RLHF for T2V. T2V RLHF is more complex than I2V because T2V motion artifacts are more varied and existing reward models "struggle to effectively differentiate fine-grained motion quality." The approach is a hybrid offline-then-online strategy:

Offline DPO stage: First, Direct Preference Optimization (DPO; Wallace et al., 2024) is applied using a curated prompt set of approximately 10K prompts (O(10K)) drawn from LLM-generated prompts and training video captions, covering diverse dimensions (motion, scene, subject, etc.). For each prompt, $N$ video candidates are generated from a high-quality SFT checkpoint, creating non-repetitive comparison pairs. These pairs are manually annotated using GSB (Good/Same/Bad) labels for semantic fidelity, motion quality, and aesthetics. DPO is then applied to this high-quality paired data.

Why offline DPO first: DPO directly optimizes the model to prefer the "good" videos over the "bad" ones from the paired data, without requiring a separate reward model (the human annotations serve as the preference signal). This avoids the reward model quality issue — human raters can distinguish fine-grained motion quality even if automated reward models cannot. The result is a "superior policy starting point" that has significantly reduced motion artifacts before online RL begins.

Online RL stage: After DPO, the exact same online RL framework developed for I2V is applied to T2V, using the same reward model dimensions and MixGRPO solver. This online stage further enhances visual quality and semantic-text alignment.

Why the two-stage RLHF for T2V: The offline DPO stage addresses the reward model's weakness at distinguishing fine motion differences by leveraging direct human preferences. The subsequent online RL stage can then use the (imperfect) reward model to optimize further, starting from a policy that already produces reasonable motion, which reduces the risk that RL will exploit reward model blind spots.

Engineering Acceleration Techniques (Beyond SSTA)

Section 6 describes additional engineering-level accelerations separate from SSTA that are applied in the "with acceleration" benchmarks (Table 8):

SageAttention (Zhang et al., 2025b): A fast attention implementation that reduces memory complexity through outlier smoothing and per-thread INT4 quantization. This operates on the full attention computation but with reduced precision and optimized memory access patterns.

torch.compile: PyTorch's JIT compiler is used to compile the DiT model, enabling kernel fusion (combining multiple operations into single GPU kernels to reduce memory bandwidth usage) and operator optimization.

Feature caching during diffusion sampling: During the 50-step diffusion process, certain intermediate features are cached and reused across non-critical steps rather than recomputed. The paper notes this avoids redundant computation while maintaining "nearly identical output quality" to full computation.

Context parallelism: All speed measurements use 8 NVIDIA H800 GPUs with context parallelism enabled, where the long sequence is split across GPUs. The reported "single GPU" memory measurements (13.6 GB peak) are achieved with pipeline offloading (offloading model layers between GPU and CPU as needed), group offloading, and VAE tiling (processing the video in spatial tiles through the VAE rather than all at once).

4. Key Insights and Innovations

Innovation 1: Video Generation Quality Is Not a Function of Parameter Count — It's a Function of Architectural Precision

The paper's most intellectually distinctive contribution is not any single component, but a reframing of the quality-vs-efficiency tradeoff in video generation as a false dichotomy stemming from architectural choices, not an inherent tension. Before this work, the dominant open-source approach to improving video quality was to scale up: Wan2.2's 27B-total/14B-activated MoE represents the logical endpoint of the "more parameters, more experts, more quality" philosophy. The paper's core diagnostic move is to reject this framing entirely. By achieving a 17.12% GSB win rate over Wan2.2 in T2V evaluation (Table 5) with an 8.3B model — roughly one-third the activated parameters — HunyuanVideo 1.5 demonstrates that the parameter-quality curve is not fundamental; it is an artifact of specific architectural design choices that prior models made.

The significance here is not "we built a smaller model that works well." It's that the paper identifies which specific aspects of prior architectures were wasting capacity. The analysis, though implicit in the design choices, points to several sources of capacity inefficiency in Wan2.2-style MoE approaches: (1) the overhead of managing and switching between multiple expert parameter sets during inference creates coordination costs that don't directly improve generation — the model must learn not just to denoise but also to route tokens appropriately between experts; (2) the hybrid MoE architecture fragments the model's representational capacity, so that each expert only sees a portion of the data distribution during training, potentially limiting the kind of cross-modal integration (text-to-motion, spatial-to-temporal) that unified video understanding requires; and (3) the separate expert models for different denoising stages create a discretization of what is fundamentally a continuous process — the transition from noise to clean video is smooth, and partitioning it between experts with different specializations may introduce boundary artifacts.

By contrast, HunyuanVideo 1.5's 8.3B parameter monolithic DiT spends all its capacity on the core denoising task, with task-specific conditioning (text, image, task type) provided through carefully designed input channels rather than separate model components. The claim being made — though the paper does not state it in these terms — is that architectural precision (getting the conditioning pathways, attention patterns, and training curriculum right) matters more than raw parameter count for video generation. This is a significant conceptual shift from the scaling-first mentality that has dominated the field, and it aligns with a broader trend in machine learning toward data quality, training efficiency, and architectural innovation over pure scale.

The evidence for this reframing is not in a single table but in the holistic pattern: competitive or superior performance against 14B-activated MoE models (Tables 3-6) combined with consumer-GPU inference capability (13.6 GB peak memory, Section 6). If quality were simply a function of parameter count, the 8.3B model should underperform substantially. It doesn't — which forces a reexamination of what those extra parameters in MoE models are actually doing.

Innovation 2: The SSTA Attention Mask as a Minimal-Sufficient Information Criterion — Not Just Another Sparse Attention Variant

SSTA might appear at first glance to be an incremental improvement on existing sparse attention methods. The paper describes it as combining static sliding window priors with dynamic global adaptive selection, which sounds like a straightforward hybrid of two well-known approaches (sliding window attention, e.g., Child et al., 2019; top-k sparse attention, e.g., Gupta et al., 2021). But the conceptual innovation is deeper: the redundancy-penalized importance scoring (Step 2 of Algorithm 1) transforms the sparse attention problem from "select the k most similar blocks" into "select the k blocks that collectively maximize information gain." This is a subtle but fundamental shift in what sparse attention is optimizing for.

Standard top-k attention selects blocks purely based on query-key similarity — the blocks whose keys are most similar to the query vector. This is a greedy relevance criterion: attend to what looks most relevant. But relevance without diversity leads to information collapse: if 20 background-sky blocks all have similar high similarity scores, top-k attention attends to all of them, wasting the sparse attention budget on redundant information.

The SSTA importance score — Score_i = λ × Score_s − β × Score_r — explicitly models this tradeoff. The Score_r term measures key-key redundancy: how much a given block's information is already represented by other blocks. By subtracting it from the similarity score, SSTA is essentially performing a lightweight form of submodular maximization: selecting blocks not just for individual relevance but for marginal information contribution given what other blocks are already in the attended set. The subtraction operation means a highly similar but highly redundant block (e.g., a 20th sky region) can be ranked below a moderately similar but unique block (e.g., the only block containing hands), because the redundancy penalty outweighs the similarity gain.

This is conceptually equivalent to applying a determinantal point process (DPP) over the attention selection — DPPs model diversity by penalizing selections where chosen items have high pairwise similarity, which is exactly what Score_r captures. The paper doesn't frame it this way explicitly, but the mathematical structure is the same.

Why is this more than an incremental tweak? Because it fundamentally changes what sparse attention means. In standard top-k, the sparsity pattern says "these are the most relevant tokens." In SSTA, the sparsity pattern says "these are the tokens that, collectively, best represent the input for the current query." The difference is between pointwise importance and setwise informativeness. This is a new semantic for sparse attention — and one that is particularly well-suited to video, where spatial redundancy is extreme (static backgrounds, repeated textures, slow-motion regions) and naive similarity-based selection would waste most of the sparse budget on redundant frames and regions.

The evidence supports this framing: SSTA achieves a 1.87× speedup over FlashAttention-3 on 241-frame 720p synthesis (Table 7) while preserving output quality, and its benefits are additive with engineering-level optimizations (1.66× additional speedup on top of SageAttention + torch.compile, Table 8). This suggests SSTA is not just reducing computation but making better decisions about where to spend attention compute, consistent with the information-maximization interpretation.

Innovation 3: RLHF for Video Is a Two-Phase Problem — Motion Quality Requires Human Preferences, Visual Quality Can Use Automated Rewards

The paper's post-training strategy (Section 4.2) makes a diagnostic claim that the field has not clearly articulated before: reward models can assess visual quality and text alignment, but they systematically fail at distinguishing fine-grained motion quality. This is not stated as a hypothesis — it is presented as an empirical finding that motivated the design: "We found that existing reward models struggle to effectively differentiate fine-grained motion quality."

This single observation has profound implications for how video generation models should be aligned. If reward models cannot reliably score motion quality, then standard online RLHF — which optimizes a reward model that approximates human preferences — will be blind to motion artifacts. The model can learn to produce visually beautiful frames with perfect text alignment while generating unnatural, jittery, or physically implausible motion, because the reward signal doesn't distinguish good motion from bad motion.

The paper's response — a hybrid offline-then-online strategy where DPO handles motion quality (via direct human preference annotations on paired videos) and online RL handles visual quality and text alignment (via automated reward models) — is a principled decomposition of the alignment problem. It acknowledges that different quality dimensions require different optimization strategies because they differ in how automatically-evaluable they are. This is conceptually analogous to the distinction in RL between dense rewards (easily computed per step) and sparse rewards (requiring episodic evaluation) — motion quality is a "sparse" signal that current reward models can't capture, so it must be injected directly through preference optimization on human-labeled data.

The significance of this goes beyond the specific DPO + RL pipeline. It identifies a fundamental limitation of automated reward models for video — and by implication, suggests that fully automated RLHF (without any human preference data) will systematically underperform on motion-critical tasks. This is not a claim the paper makes explicitly, but it follows directly from the diagnostic observation. If reward models are blind to motion quality, then any alignment method that relies solely on reward models will be blind to motion quality.

The evidence: the paper reports that the two-stage T2V RLHF (offline DPO followed by online RL) produces "significant reductions in motion artifacts" and "consistent improvements across all evaluation metrics, with particularly notable gains in motion realism" (for I2V online RL). The motion effect scores in the Rating evaluation (Tables 3 and 4) provide quantitative support — HunyuanVideo 1.5 achieves 57.67 (T2V) and 57.60-58.62 (I2V), competitive with proprietary systems. Without the two-phase strategy, motion quality would likely be the weakest dimension, as it has been for many prior open-source models.

Innovation 4: The "Difficulty" of Video Training Is Not About Data Quantity — It's About Match Between Token Length Distributions and Flow Matching Shift Parameters

A subtler but important technical insight emerges from the training methodology: flow matching-based video generation is particularly sensitive to the alignment between the shift hyperparameter and the token length distribution, and progressive training stages require explicit shift scheduling to maintain stability (Section 4.1). This is not a major theoretical breakthrough, but it is an empirical diagnostic that calls out a failure mode many practitioners may have encountered without understanding its root cause.

The paper states that "flow matching-based training is particularly sensitive to the shift hyper-parameter when video token lengths vary across stages." In flow matching, the shift parameter controls the shape of the probability path between the noise distribution and the data distribution — essentially, how quickly samples transition from noise-like to data-like as the diffusion time progresses. When token lengths change dramatically (as they do when moving from 256p 2-second videos to 720p 10-second videos), the optimal shift also changes, because the effective dimensionality and information content of the data distribution changes. Training with a fixed shift across all stages would mean the model is being optimized under a mismatch between the forward process and the data characteristics at some resolutions or durations.

The fix — "carefully designed shift scheduling strategies that adapt to different token lengths" — is a practical engineering solution. But the conceptual contribution is the identification of the problem as a first-class training stability issue. Prior work (Esser et al., 2024) noted that flow matching is sensitive to sequence length, but the paper connects this sensitivity specifically to the progressive multi-resolution training curriculum that is standard in video generation. The implication is that naive progressive training (simply increasing resolution and duration without adjusting the flow matching dynamics) is likely to be suboptimal or unstable, and that shift scheduling is as important as learning rate scheduling for multi-stage video training.

This is a relatively incremental contribution compared to the architectural innovations or the RLHF strategy, but it addresses a practical pain point that could explain why some video generation models fail to improve — or even degrade — during later training stages. The evidence is indirect (the paper reports stable training and good final performance, but no ablation of shift scheduling vs. fixed shift), but the diagnostic claim is specific and actionable for practitioners.

5. Experimental Analysis

Evaluation Methodology

Dataset. The training dataset comprises 5 billion images for T2I pre-training (curated from over 10 billion, Section 2.1), approximately 800 million high-quality video segments for video pre-training (filtered from over 10 million hours of raw video), and 1 million high-quality video clips each for T2V and I2V post-training CT stages (Table 2). The paper does not describe a separate held-out test set used for evaluation — instead, evaluation is conducted on a purpose-constructed benchmark of 300 diverse text prompts for T2V and 300 image samples for I2V, designed to "cover balanced application scenarios" (Section 5.2). The source of these prompts and images is not specified beyond being "carefully constructed."
Base model. The core model is a Diffusion Transformer (DiT) with 8.3 billion parameters, using 54 dual-stream blocks, model dimension 2048, FFN dimension 8192, 16 attention heads, and head dimension 128 (Table 1). The DiT is built on a causal 3D VAE with 16× spatial and 4× temporal compression and latent channel dimension 32. For the video super-resolution network, the architecture is identical to the main DiT but initialized from a pretrained T2V checkpoint (Section 4.3). The model supports three tasks: text-to-image (T2I), text-to-video (T2V), and image-to-video (I2V).
Metrics. Two evaluation methodologies are employed (Section 5 introduction): Rating and GSB (Good/Same/Bad). The Rating method provides a comprehensive multi-dimensional assessment where professional evaluators score model outputs across five dimensions: for T2V — text-video consistency, aesthetic quality of individual frames, visual quality, structural stability, and motion effects (Table 3); for I2V — image-video consistency, instruction responsiveness, visual quality, structural stability, and motion effects (Table 4). The exact scoring scale and rubric are not specified, and the number of evaluators for Rating is not reported. The GSB method evaluates pairwise relative performance: for each prompt or image input, one video sample is generated by each of two models in a single run (no cherry-picking), and over 100 professional assessors judge whether the first model is Good, Same, or Bad relative to the second. The "HY Win Rate" is computed as the percentage of cases where HunyuanVideo 1.5 is rated better minus the percentage where the competitor is rated better (Section 5.2). GSB evaluation is conducted for both T2V (Table 5) and I2V (Table 6).
Baselines. The paper evaluates against five models — a mix of open-source and proprietary systems. In the open-source category: Wan2.2 (Wan et al., 2025), a 27B-total/14B-activated MoE video generation model with a separate 5B compact variant. In the proprietary category: Kling2.1 Master (Kuaishou Technology, 2025), Seedance Pro (specific developer not cited in the paper, presumably ByteDance based on product naming conventions but not explicitly attributed), and Veo3 (Google DeepMind, 2025). For T2V evaluation (Tables 3 and 5), all four competitors are evaluated. For I2V evaluation (Tables 4 and 6), the same four competitors plus HunyuanVideo 1.5 in two configurations (480pSR and direct 720p) are evaluated. The specific version numbers, inference configurations, and prompt-handling details for competitor models are not described beyond noting that "all competing models are evaluated using their default configurations" (Section 5.2). This is a significant methodological limitation: the prompts used for evaluation, the classifier-free guidance scales, the number of diffusion steps, and any prompt-engineering steps applied to competitors are not disclosed, making the comparison potentially sensitive to implementation choices.
Generation budget / compute accounting. For evaluation purposes, all models generate exactly one video per prompt or image input — "an equal number of video samples are generated by each model in a single run to ensure comparability... inference is performed only once per input without any cherry-picking of results" (Section 5.2). There is no explicit FLOP counting, parameter-matched comparison, or compute budget normalization across models in the evaluation. The comparison is purely output-quality-based: each model gets one attempt per input using whatever inference hyperparameters its developers set as defaults. This means the evaluation does not control for inference cost — Wan2.2's 14B-activated MoE may use substantially more compute per generated video than HunyuanVideo 1.5's 8.3B DiT, and proprietary models could use even more. The inference speed and memory benchmarks (Section 6, Tables 7-8) are reported separately from the quality evaluation and are not integrated into a compute-matched quality comparison.
Cross-validation / statistical protocol. The paper does not report confidence intervals, standard errors, statistical significance tests, or any form of cross-validation for the quality evaluation. The GSB evaluation uses over 100 professional assessors, but inter-annotator agreement (e.g., Krippendorff's alpha, Fleiss' kappa) is not reported. The Rating evaluation does not specify the number of raters or any measure of rater reliability. The 300 prompts and 300 images for GSB evaluation are fixed — there is no bootstrapping, subsampling, or multiple evaluation runs to characterize variance. For the training methodology, the paper mentions "two-fold cross-validation" is not used; the only validation signal described is for the caption model post-training (Section 2.2) and for early stopping during revision model training, neither of which applies to the main evaluation. The absence of statistical rigor is a significant limitation of the evaluation — the GSB win rates in Tables 5 and 6 (e.g., 17.12% over Wan2.2, 12.6% over Kling2.1 Master) are reported as point estimates without any characterization of how stable these numbers are across different prompt sets, different random seeds, or different annotator groups.

Main Quantitative Results

Headline Comparisons: HunyuanVideo 1.5 vs. Open-Source (Wan2.2) and Proprietary Systems

The central quantitative claim of the paper is that HunyuanVideo 1.5, with its 8.3B parameters, either matches or exceeds the quality of substantially larger open-source models and is competitive with proprietary systems. The evidence comes from two evaluation methodologies — Rating (multi-dimensional absolute scoring) and GSB (pairwise relative preference) — applied separately to T2V and I2V tasks.

T2V Rating (Table 3). HunyuanVideo 1.5 achieves the following dimensional scores alongside four competitors:

Dimension	HY1.5 720p	Wan2.2	Kling2.1 Master	Seedance Pro	Veo3
Instruction following	61.57	44.07	50.03	53.19	73.77
Aesthetic quality	63.30	65.98	68.00	68.22	67.98
Visual quality	57.35	56.37	59.68	60.20	58.64
Structural stability	79.75	73.75	66.74	68.69	75.62
Motion effects	57.67	53.08	58.59	55.17	60.81

The pattern is clear and non-uniform across dimensions. HunyuanVideo 1.5 leads substantially on two dimensions: Instruction following (61.57, which is 8.38 points ahead of Seedance Pro at 53.19, and 17.5 points ahead of Wan2.2 at 44.07) and Structural stability (79.75, which is 4.13 points ahead of Veo3 at 75.62 and 13.01 points ahead of Kling2.1 Master at 66.74). These are the dimensions most directly related to the model's core architectural capabilities — instruction following reflects the dual-channel text encoding (Qwen2.5-VL for semantics, Glyph-ByT5 for glyph awareness) and the multi-task training, while structural stability reflects temporal coherence and the absence of frame-to-frame artifacts.

HunyuanVideo 1.5 trails on Aesthetic quality (63.30 vs. 65.98–68.22 for competitors), Visual quality (57.35 vs. 56.37–60.20), and Motion effects (57.67 vs. 53.08–60.81). The aesthetic quality gap is notable — HunyuanVideo 1.5 scores roughly 4.7 points behind Kling2.1 Master and Seedance Pro. This suggests the compact architecture, while efficient, may not match the aesthetic refinement achievable with larger parameter budgets or more extensive aesthetic-focused post-training. The Veo3 comparison is particularly informative: Veo3 leads on Instruction following (73.77, a dominant score) and Motion effects (60.81), but HunyuanVideo 1.5 leads on Structural stability (79.75 vs. 75.62) — suggesting the two models have complementary strengths.

T2V GSB (Table 5). The pairwise preference evaluation against four competitors, with 300 prompts, yields:

Compared Model	HY Better	Other Better	Equally Bad	Equally Good	HY Win Rate
Wan2.2	34.90%	17.78%	40.70%	6.62%	17.12%
Kling2.1 Master	31.55%	18.95%	42.76%	6.75%	12.60%
Seedance Pro	31.67%	20.65%	38.61%	9.06%	11.02%
Veo3	24.64%	34.96%	30.71%	9.69%	−10.32%

The GSB results confirm the Rating pattern with some nuances. Against Wan2.2 — the most direct open-source competitor — HunyuanVideo 1.5 is preferred almost twice as often (34.90% vs. 17.78%), yielding a win rate of 17.12 percentage points. However, the largest category is "Equally Bad" at 40.70% — meaning that for over 40% of prompts, both models produce outputs that evaluators consider unacceptable. This is a sobering reality check: even the best open-source models fail to produce satisfactory output on a substantial fraction of prompts. Only 6.62% of prompts produce "Equally Good" outputs from both models, suggesting that when one model succeeds, the other typically does not.

Against proprietary systems, the win rate declines as expected: 12.60% over Kling2.1 Master, 11.02% over Seedance Pro, and −10.32% against Veo3 (meaning Veo3 is preferred significantly more often). The Veo3 result is the only case where HunyuanVideo 1.5 has a negative win rate, confirming that Veo3 represents a higher quality tier. The "Equally Bad" category remains high across all comparisons (30.71–42.76%), indicating that even the best proprietary models produce unsatisfactory output on a significant fraction of challenging prompts.

I2V Rating (Table 4). HunyuanVideo 1.5 is evaluated in two configurations: direct 720p generation and "480pSR" (480p generation upscaled to 720p via the video super-resolution network):

Dimension	HY1.5 480pSR	HY1.5 720p	Wan2.2	Kling2.1 Master	Seedance Pro	Veo3
Instruction following	63.11	63.05	56.19	68.43	62.90	67.86
Image consistency	68.82	72.07	73.53	64.09	73.06	72.19
Visual quality	59.87	60.33	58.31	59.28	58.95	59.29
Structural stability	70.13	66.67	69.03	59.71	68.01	69.25
Motion effects	57.60	58.62	57.41	57.36	60.47	60.91

For I2V, the competitive landscape shifts. HunyuanVideo 1.5 no longer leads on Instruction following — Kling2.1 Master (68.43) and Veo3 (67.86) both outperform it (63.05 for direct 720p). On Image consistency, HunyuanVideo 1.5 (72.07) is competitive with the best models (Wan2.2 at 73.53, Seedance Pro at 73.06, Veo3 at 72.19) and substantially outperforms Kling2.1 Master (64.09). Structural stability is where HunyuanVideo 1.5 excels, with 70.13 for 480pSR (highest in the table) and 66.67 for direct 720p. The 480pSR vs. direct 720p comparison is instructive: 480pSR achieves slightly better Instruction following (63.11 vs. 63.05), better Structural stability (70.13 vs. 66.67), but lower Image consistency (68.82 vs. 72.07). This suggests the super-resolution process improves temporal coherence at a modest cost to precise image-condition alignment.

I2V GSB (Table 6). Pairwise preferences for I2V reveal a different pattern from T2V:

Compared Model	HY Better	Other Better	Equally Bad	Equally Good	HY Win Rate
Wan2.2	45.60%	32.95%	18.60%	2.85%	12.65%
Kling2.1 Master	40.60%	30.88%	22.73%	5.79%	9.72%
Seedance Pro	30.62%	36.39%	26.61%	6.38%	−5.77%
Veo3	37.44%	41.05%	18.44%	3.07%	−3.61%

The I2V win rates are generally lower than T2V — 12.65% over Wan2.2 (vs. 17.12% for T2V) and 9.72% over Kling2.1 Master (vs. 12.60%). Both Seedance Pro and Veo3 receive higher preference rates than HunyuanVideo 1.5, with negative win rates of −5.77% and −3.61% respectively. Notably, the "Equally Bad" rates are substantially lower for I2V (18.44–26.61%) compared to T2V (30.71–42.76%), suggesting that I2V generation is generally more successful across all models — likely because the reference image provides strong conditioning that reduces the space of possible failures.

Comparative analysis across T2V and I2V. Several patterns emerge when comparing across tasks:

HunyuanVideo 1.5 is stronger at T2V than I2V relative to competitors — its win rates are higher against Wan2.2 (17.12% vs. 12.65%) and Kling2.1 Master (12.60% vs. 9.72%), and it has a positive win rate against Seedance Pro in T2V (11.02%) but negative in I2V (−5.77%).
Veo3 leads across both tasks — it is the only model with a positive win rate against HunyuanVideo 1.5 in T2V (−10.32%) and one of two in I2V (−3.61%).
Instruction following is the dimension where HunyuanVideo 1.5 most clearly excels in T2V (61.57, best among non-Veo3 models) but where it is weakest relative to competitors in I2V (63.05, behind Kling2.1 Master at 68.43 and Veo3 at 67.86). This suggests the I2V conditioning mechanism (VAE concatenation + SigLip embeddings) may not leverage the text encoder's capabilities as effectively as the T2V pathway.

Inference Efficiency Results (Section 6)

The paper reports inference speed and memory benchmarks separately from quality evaluation, establishing the efficiency side of the quality-efficiency tradeoff claim.

Speed without engineering acceleration (Table 7). Measured as wall-clock time per diffusion step on 8 NVIDIA H800 GPUs with context parallelism:

Task	Resolution	Total Frames	Sparse Attention	Time/Step (s)
T2V	480p	121	✗	0.9064 ± 0.0062
T2V	480p	241	✗	1.7015 ± 0.0203
T2V	720p	121	✗	2.0084 ± 0.0229
T2V	720p	121	✓	1.5638 ± 0.0150
T2V	720p	241	✗	5.5070 ± 0.0284
T2V	720p	241	✓	2.9475 ± 0.0206

The headline result: SSTA reduces per-step time for 241-frame 720p generation from 5.5070s to 2.9475s, a 1.87× speedup. The benefit is smaller for 121-frame 720p (2.0084s to 1.5638s, a 1.28× speedup), demonstrating that SSTA's advantage grows with sequence length — precisely what we would expect from an attention mechanism that reduces quadratic complexity.

Doubling frames from 121 to 241 without SSTA increases time from 2.0084s to 5.5070s (2.74× increase for 2× frames) — worse than linear scaling, consistent with quadratic attention complexity. With SSTA, doubling frames increases time from 1.5638s to 2.9475s (1.89× increase for 2× frames) — better than linear, approaching sub-quadratic scaling behavior. This confirms SSTA's effectiveness at reducing the asymptotic complexity of attention for long videos.

Speed with engineering acceleration (Table 8). With SageAttention, torch.compile, and feature caching enabled, measured as total time for 50 diffusion steps:

Task	Resolution	Total Frames	Sparse Attention	Total Time (s)	Avg Time/Step
T2V	480p	121	✗	13.90	0.2781
T2V	480p	241	✗	27.08	0.5418
T2V	720p	121	✗	28.33	0.5667
T2V	720p	121	✓	26.41	0.5283
T2V	720p	241	✗	96.78	1.9356
T2V	720p	241	✓	58.39	1.1679

The key finding: SSTA provides additional speedup on top of engineering optimizations, not redundant with them. For 241-frame 720p, the combination of engineering acceleration + SSTA achieves 1.1679s per step vs. 1.9356s per step with engineering acceleration alone — a 1.66× additional speedup. If SSTA were merely approximating what engineering optimizations already do (e.g., if SageAttention's quantization already effectively reduced the attention cost), we would expect the marginal benefit to shrink or disappear. The fact that it persists confirms SSTA is eliminating attention computation that engineering-level optimizations still perform.

For 121-frame 720p, the benefit is minimal (0.5667s to 0.5283s, only 1.07×). This aligns with the finding from Table 7 that SSTA's advantage scales with sequence length.

GPU memory (Section 6). "When pipeline offloading, group offloading, and VAE tiling are enabled, the entire pipeline can complete end-to-end inference for 720p 121-frame T2V/I2V generation with a peak memory of 13.6 GB, thereby enabling inference on a single consumer-grade GPU (e.g., RTX 4090)." This is measured on a single GPU configuration, contrasting with the speed measurements that use 8 GPUs. The 13.6 GB figure is the critical number for the paper's accessibility claim — it demonstrates that the model can run on hardware that individual developers and researchers actually own.

What is not reported. The paper does not report GPU memory requirements for the competitors (Wan2.2, proprietary models), making it impossible to compute a formal "quality per GB" or "quality per FLOP" metric. We know HunyuanVideo 1.5 achieves 17.12% GSB win rate over Wan2.2 (Table 5), but we don't know whether Wan2.2's inference uses more or less memory — only that its 27B total parameters suggest higher memory requirements. Similarly, we don't know the inference speed of competitor models, so the "efficiency" comparison is one-sided: HunyuanVideo 1.5's efficiency is quantified, but competitors' efficiency is not. The quality-efficiency tradeoff claim is supported by showing HunyuanVideo 1.5 is both high-quality and efficient, not by showing it dominates a quality-efficiency Pareto frontier against measured competitors.

Ablation Studies and Robustness Checks

The paper contains notably few formal ablation studies. Most design choices are justified through final performance rather than controlled experiments that isolate the contribution of individual components. The following are the closest approximations to ablations present in the paper:

SSTA vs. full attention (Tables 7 and 8). The speed measurements with and without sparse attention constitute an implicit ablation showing SSTA's computational benefit. However, this is purely a speed ablation — no quality comparison between SSTA and full attention is reported. We do not know whether the 1.87× speedup comes at any cost to visual quality, motion coherence, or instruction following. The paper states that SSTA is integrated during the distillation phase "which more effectively preserves output quality" (Section 3.1), implying that quality is maintained, but no evidence is provided. This is a significant gap — a speed-quality tradeoff curve for SSTA at different sparsity levels (varying k, window size, or the λ/β weights) would substantially strengthen the claim that SSTA is "free" in quality terms.

480pSR vs. direct 720p for I2V (Table 4). The comparison between "HY1.5 480pSR" (generate at 480p, super-resolve to 720p) and "HY1.5 720p" (generate directly at 720p) serves as an ablation of the super-resolution pipeline within the I2V task:

480pSR achieves better Structural stability (70.13 vs. 66.67) and comparable Instruction following (63.11 vs. 63.05)
480pSR achieves lower Image consistency (68.82 vs. 72.07) and slightly lower Visual quality (59.87 vs. 60.33)

This suggests the VSR network improves temporal coherence at a modest cost to image-condition fidelity — a meaningful finding for practitioners deciding between the two deployment modes. However, no speed or memory comparison between 480pSR and direct 720p is reported, making the efficiency tradeoff unclear.

Muon vs. AdamW (Section 4.1, no table). The paper states that Muon "attains a lower training loss than AdamW in only half the number of training steps, while also yielding superior performance across multiple text-to-image benchmarks." No training loss curves, convergence plots, or benchmark comparisons are shown. The claim is asserted without evidence in the paper, referencing the Kimi K2 technical report (Team et al., 2025) where Muon was introduced. This is not an ablation performed in this paper — it is an adoption of a finding from prior work.

RLHF components (Section 4.2, no table). The paper describes a multi-stage post-training pipeline for T2V (offline DPO followed by online RL) motivated by the finding that "existing reward models struggle to effectively differentiate fine-grained motion quality." However, no ablation compares: (1) online RL only (without DPO), (2) DPO only (without online RL), and (3) the full hybrid pipeline. Figure 4 shows qualitative examples across post-training stages, but the captions are minimal and no quantitative comparison is provided. The claim that the two-stage approach yields improvements is supported by the final evaluation numbers, but the marginal contribution of each stage is unknown.

Caption model RL (Section 2.2, no table). The paper describes using OPA-DPO (Yang et al., 2025) for the caption model to address the richness-hallucination tradeoff (Figure 1). No ablation compares model performance with and without this RL post-training of the captioner — we don't know whether improved captions translate to improved video generation quality.

Data volume scaling (Table 2, no quality comparison across stages). The training curriculum uses decreasing data volumes at higher resolutions (800M → 200M → 100M → 100M). No experiments examine whether more data at later stages would improve quality, or whether the chosen volumes are saturated.

Task mixing ratio (Section 4.1, no ablation). The T2I:T2V:I2V ratio of 1:6:3 is stated but not justified with comparisons to alternative ratios. We don't know whether 1:6:3 is optimal, or whether the model is robust to this choice.

The absence of systematic ablation studies is a significant weakness of the paper's experimental design. The final evaluation demonstrates that the complete system works well, but provides little insight into why it works or which components are essential. This limits the paper's value as a research contribution — practitioners cannot determine which design choices to prioritize in their own implementations, and researchers cannot build on the findings without replicating substantial portions of the system.

Critical Assessment

Has the paper demonstrated that SSTA achieves meaningful speedup without quality degradation?

Verdict: Partially demonstrated — speedup is shown, quality preservation is asserted but not measured.

The speedup measurements (Tables 7 and 8) are clear and well-measured, with mean and standard deviation reported for per-step time. The 1.87× speedup for 241-frame 720p synthesis without engineering acceleration, and the 1.66× additional speedup on top of engineering optimizations, are convincing evidence that SSTA reduces computation.

However, the paper never compares the quality of SSTA-generated videos to full-attention-generated videos. The claim that SSTA "more effectively preserves output quality" (Section 3.1) is purely qualitative reasoning about the distillation-phase integration. We don't know whether the 1.87× speedup comes with a 1% degradation, a 5% degradation, or zero degradation in GSB win rates or Rating scores. For a mechanism that dynamically prunes attention connections — potentially dropping semantically important but statistically unusual token relationships — quality degradation is a real risk that the paper should have quantified.

A simple experiment would close this gap: run the same 300 GSB prompts with and without SSTA (at the same resolution, same number of frames, same random seeds) and report the quality difference. The fact that this experiment was not run, despite being straightforward and clearly relevant to the paper's central claims, is a notable omission.

Has the paper demonstrated that compact architecture (8.3B) matches or exceeds larger open-source models (27B Wan2.2)?

Verdict: Supported for the specific models and evaluation protocol tested, but with important caveats about generalizability.

The GSB results (Tables 5 and 6) clearly show HunyuanVideo 1.5 preferred to Wan2.2 in pairwise comparison, with a 17.12% win rate for T2V and 12.65% for I2V. These are substantial margins, and the evaluation protocol (300 diverse prompts, single generation per prompt, over 100 professional assessors, no cherry-picking) is reasonable.

However, several caveats limit how strongly we can interpret this as a general "compact beats large" finding:

The comparison is between specific models, not between architectural paradigms. Wan2.2 is one particular MoE implementation with one particular training recipe, data mixture, and post-training pipeline. HunyuanVideo 1.5 outperforming Wan2.2 doesn't demonstrate that monolithic DiTs outperform MoE architectures in general — it demonstrates that the HunyuanVideo team's specific design choices and training pipeline produced a better model than the Wan2.2 team's. The Paper doesn't control for training data quality, caption quality, post-training investment, or engineering effort.
No compute-matched comparison. Wan2.2's inference cost is unknown (the paper doesn't measure it). If Wan2.2 generates one 720p video in 5 seconds on 8 H800 GPUs, and HunyuanVideo 1.5 generates one in 20 seconds, the quality comparison is still valid but the efficiency interpretation changes. The paper's framing is that HunyuanVideo 1.5 achieves competitive quality while being more efficient, but the efficiency comparison is reported separately and not linked to the quality comparison.
The "Equally Bad" rate is very high. For T2V GSB against Wan2.2, 40.70% of prompts produce equally bad outputs from both models. This means the comparison is only informative for the ~53% of prompts where at least one model produces acceptable output. On the remaining 47%, neither model succeeds. This doesn't invalidate the comparison, but it contextualizes the finding: both models fail on a large fraction of challenging prompts, and the win rate is computed over a subset of prompts where differentiation is possible.
Single evaluation run per prompt. Generating one video per prompt and having it evaluated once introduces noise from both the generation stochasticity and the evaluator subjectivity. Multiple generations per prompt with multiple evaluator ratings would provide more reliable estimates and enable variance characterization.

Has the paper demonstrated that HunyuanVideo 1.5 achieves practical consumer-GPU deployment?

Verdict: Supported with quantification — the 13.6 GB peak memory figure is specific and actionable.

The reported 13.6 GB peak GPU memory for 720p 121-frame generation on a single GPU with offloading and tiling enabled (Section 6) is a concrete, verifiable claim. An RTX 4090 with 24 GB VRAM can clearly accommodate this, and the 13.6 GB figure leaves headroom for operating system and driver overhead. This is genuinely useful information for practitioners.

The limitation is that only one configuration (720p, 121 frames) is reported. Memory requirements for 480p, for longer videos (241 frames), and for I2V (which requires additional image encoding) are not specified. The offloading strategies (pipeline offloading, group offloading, VAE tiling) are mentioned but not detailed — we don't know the latency cost of these techniques, which could be substantial if they involve CPU-GPU transfers during inference.

Has the paper demonstrated that the dual-channel text encoding improves bilingual understanding and text rendering?

Verdict: Asserted in contributions but not experimentally validated.

The paper claims "enhanced bilingual understanding through glyph-aware text encoding" as a key contribution, and the dual-channel Qwen2.5-VL + Glyph-ByT5 design is described in Section 3.1. However, no experiment compares this dual-channel design to any baseline — not to a single-encoder baseline (Qwen2.5-VL only), not to an alternative character-aware encoder, not to a baseline without Glyph-ByT5. There are no bilingual-specific evaluation prompts, no text-rendering accuracy metrics, and no analysis of Chinese vs. English prompt handling.

The Rating evaluation's "Instruction following" dimension (Table 3) may partially capture text understanding, but it is a composite score that includes visual instruction following, not just language understanding. We cannot attribute the strong Instruction following score (61.57) to the dual-channel text encoding specifically — it could equally be due to the training data quality, the multi-task training, the captioning pipeline, or the post-training.

This is arguably the most significant missing experiment in the paper, given that bilingual understanding and text rendering are explicitly claimed as contributions. A simple ablation comparing the full model to a Glyph-ByT5-ablated variant on a bilingual prompt set with text-rendering requirements would directly test this claim.

Has the paper demonstrated that RLHF post-training improves video quality?

Verdict: Qualitative evidence present, quantitative evidence missing.

Figure 4 shows visual examples across post-training stages, and the paper describes improvements in "output stability, visual quality, aesthetic appeal, and temporal consistency" from CT and SFT, and "significant reductions in motion artifacts" from RLHF. However, no quantitative ablation compares pre-RLHF and post-RLHF models on the 300-prompt GSB benchmark or the Rating dimensions. Without this, we cannot determine the marginal value of the extensive post-training pipeline relative to the pre-trained base model.

The post-training pipeline is clearly sophisticated — online RL with a custom VLM reward model for I2V, offline DPO + online RL for T2V, curated prompt sets, manual annotation — and represents substantial engineering investment. Quantifying the return on this investment would make the paper significantly more valuable to practitioners deciding whether to implement similar post-training in their own pipelines.

Missing experiments that would strengthen the paper

SSTA quality ablation: Generate the same videos with and without SSTA, compare quality.
Text encoder ablation: Compare dual-channel (Qwen2.5-VL + Glyph-ByT5) to Qwen2.5-VL-only on a bilingual prompt set with text-rendering challenges.
Post-training stage ablation: Compare pre-trained base model, pre-trained + CT, pre-trained + CT + SFT, and full model with RLHF on the GSB benchmark.
Data scale sensitivity: Compare models trained with different data volumes at each stage to determine whether the ~800M video clips are saturated.
Competitor inference cost measurement: Report GPU memory and inference time for Wan2.2 and at least one proprietary model (via API latency measurement) to enable quality-per-FLOP comparison.
Multi-run evaluation: Generate multiple videos per prompt (with different seeds) and have multiple evaluators rate each, to quantify within-model variance and inter-evaluator reliability.
Scaling behavior: Train smaller variants (e.g., 4B, 2B parameters) and measure the quality-parameter scaling curve to contextualize the 8.3B choice.

Overall assessment of experimental rigor

The evaluation demonstrates that HunyuanVideo 1.5 is a high-quality video generation model competitive with state-of-the-art open-source and proprietary systems — the GSB win rates against Wan2.2 and Kling2.1 Master are credible and consistent across T2V and I2V. The inference efficiency claims are well-quantified and practically relevant.

However, the paper's experimental design is fundamentally a system demonstration, not a controlled scientific study. The contributions are evaluated holistically — the complete system against competitor complete systems — without isolating the effect of individual design choices. The claims about why the model works (dual-channel encoding, SSTA, progressive training, RLHF) are supported by architectural reasoning and qualitative examples, not by controlled experiments. For a paper whose primary audience is practitioners looking to build or deploy video generation models, the lack of ablations is a significant limitation — it leaves unanswered the most practical question: "Which of these components do I actually need to implement to get good results?"

The paper's title is accurate in calling itself a "Technical Report" rather than a research paper. It documents the design and performance of a system, not a set of scientific findings validated through controlled experimentation. The evaluation is sufficient to establish that the system works and is competitive, but insufficient to establish why each component matters or to guide future research beyond replicating the full recipe.

6. Limitations and Trade-offs

Difficulty Estimation Cost Is Unaccounted For — Making the Headline 4× Efficiency Gain a Theoretical Upper Bound

The assumption or constraint. The compute-optimal scaling framework (Section 3.2) requires estimating each prompt's difficulty before allocating the inference budget. The paper uses two methods: oracle difficulty (computing pass@1 over 2048 samples with ground-truth labels) and predicted difficulty (averaging the PRM's final-answer score over 2048 samples). Both require generating and scoring 2048 complete solutions per question before any problem-solving begins. The paper acknowledges this explicitly:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity" (Section 3.2)

This means the 2048-sample difficulty estimation step is completely excluded from the reported generation budgets. When the paper claims compute-optimal scaling achieves equivalent accuracy with 4× fewer generations than best-of-N (e.g., 16 generations matching 64 in Figure 4), those 16 generations are the problem-solving budget only — the 2048 samples spent on difficulty estimation are not included.

The consequence. If difficulty estimation costs dominate the total inference budget, the practical efficiency gains could be negative — meaning compute-optimal scaling might be more expensive overall than simply running best-of-N with a large fixed budget. The paper never quantifies what happens if difficulty estimation is amortized or simplified. A user deploying this system would need to either (a) accept the 2048-sample upfront cost per prompt, (b) amortize it across many similar prompts by caching difficulty estimates, or (c) develop a cheaper difficulty estimator not evaluated in the paper. None of these are validated.

The severity depends on the deployment context. For batch evaluation of a fixed test set, the difficulty estimation cost is amortized across all prompts (you estimate difficulty once per prompt, then use the optimal strategy). For single-prompt interactive use, the 2048-sample upfront cost would dominate, making the approach completely impractical. The paper does not distinguish between these scenarios.

What evidence exists in the paper. The paper never reports a total-cost-inclusive comparison. Figure 4 shows compute-optimal scaling curves where the x-axis (generation budget) counts only the strategy execution cost, not the 2048-sample difficulty estimation cost. The paper flags this explicitly as a limitation (Section 3.2, Section 8) but provides no sensitivity analysis showing whether the 4× efficiency claim survives when difficulty estimation is included — even under optimistic assumptions about amortization.

Mitigation status. The paper acknowledges the issue and delegates it to future work:

"We leave the design of more efficient methods for estimating question difficulty — such as via pretraining or finetuning models to directly predict difficulty of a question — to future work" (Section 8)

No partial mitigation is attempted — no amortization analysis, no sensitivity study showing at what prompt volume the estimation cost becomes negligible, no ablation of simpler difficulty estimators (e.g., using 64 samples instead of 2048). The reported 4× efficiency is therefore a best-case upper bound that assumes difficulty is known for free.

Hard Problems (Difficulty Bin 5) Show Near-Zero Improvement Regardless of Compute Budget or Strategy

The assumption or constraint. The compute-optimal framework implicitly assumes that test-time compute can meaningfully improve performance across the difficulty spectrum. However, the paper's own analysis reveals a hard failure mode: for questions in difficulty bin 5 (the hardest quintile, where the base model's pass@1 is near zero), no method produces meaningful gains regardless of how much test-time compute is allocated.

The consequence. This is not just "diminishing returns" — it is a capability ceiling. The framework cannot help with problems the base model fundamentally cannot solve. A practitioner encountering a distribution of prompts that skews toward bin-5 difficulty would find the entire compute-optimal framework useless, because no strategy, no budget, no search algorithm improves over random guessing. This is a deployment-critical limitation: it means the system cannot be relied upon for genuinely challenging problems, and there is no diagnostic that warns the user "this problem is beyond my capability" before compute is spent. The system will allocate test-time compute and fail anyway.

What evidence exists in the paper. The evidence is stark and consistent across multiple analyses:

In search experiments (Figure 3, right panel), bin 5 accuracy hovers at roughly 1–3% for all methods (best-of-N weighted, beam search) and all budgets (4 to 256 generations). The curves are essentially flat lines near zero.
In revision experiments (Figure 7, right panel), bin 5 accuracy remains at roughly 2–3% across all sequential-to-parallel ratios at 128 generations.
In the FLOPs-matched comparison (Figure 9), the bin 5 scaling line is essentially flat near 0–5% for revisions and near 0–3% for PRM search. The ~14× larger model's greedy performance is also near zero on these problems, confirming they are genuinely hard — not just poorly served by test-time compute.

The paper is transparent about this limitation:

"On the hardest questions (bin 5), no method makes meaningful progress — the base model simply lacks the capability to produce correct solutions regardless of how the budget is allocated." (Section 5.3)

Mitigation status. The paper does not attempt to solve this. It frames the finding as an important boundary condition — test-time compute amplifies existing capability but cannot create it — which is a valid and honest characterization. However, the paper does not provide diagnostics for identifying bin-5 problems before spending compute, which would be the minimum practical mitigation. A user who doesn't know their prompt falls into bin 5 would waste the full allocated budget with no chance of success.

The Revision Model Systematically Reverts Correct Answers to Incorrect — 38% Reversion Rate

The assumption or constraint. The revision model (Section 6) is trained on sequences where all in-context answers are incorrect, followed by a correct target. This means during training, the model never sees a correct answer in its context — it only learns to transform incorrect answers into correct ones. At inference time, when the model generates a correct answer during a revision chain, that correct answer enters the context for subsequent revision steps. The model has no training signal for what to do in this situation and frequently "revises" correct answers back into incorrect ones.

The consequence. This reversion problem fundamentally limits the effectiveness of long sequential revision chains. The paper reports:

"approximately 38% of correct answers get converted back to incorrect ones using a naive approach" (Section 6.1)

This means the revision chain is not monotonic in quality — later steps can be worse than earlier steps. Selection mechanisms (majority voting or verifier-based selection across the chain) partially mitigate this by picking the best answer from any point in the chain rather than always taking the final revision, but they are imperfect patches. If the verifier itself makes errors (and Section 5.3 documents verifier over-optimization as a significant problem), it may fail to identify which step in the chain contains the best answer, potentially selecting an incorrect revision that replaced a correct earlier answer.

Moreover, the 38% reversion rate means that for revision chains longer than a few steps, the probability that all correct answers eventually get reverted approaches 1. The expected time a correct answer survives in the chain is roughly 1/0.38 ≈ 2.6 revision steps, after which it is likely replaced by an incorrect answer. This puts a hard ceiling on the maximum effective chain length, regardless of budget.

What evidence exists in the paper. The 38% figure is cited explicitly in Section 6.1, though the experimental derivation of this number is not detailed (it's unclear what prompt set, what revision chain length, and what model checkpoint produced this measurement). The paper acknowledges the issue:

"To mitigate this, the system uses a selection mechanism (majority voting or verifier-based selection) across the entire chain of revisions, picking the best answer from any point in the chain rather than always taking the last revision."

Figure 6 (left) shows that pass@1 at each revision step does gradually improve overall (from ~18.2% at step 1 to ~24–25% by steps 15–20), indicating that on average, the revision process is net-beneficial despite the reversion problem. But the figure shows aggregate statistics — it doesn't reveal how many individual chains suffer from correct-to-incorrect reversions.

Mitigation status. The mitigation (within-chain selection) is a workaround, not a solution. It doesn't prevent the reversion — it just tries to detect and ignore it after the fact. A more principled solution — such as training the revision model on trajectories that include correct answers in context (teaching it to recognize when no revision is needed) — is not explored. The ReST^EM experiment (Appendix K, Figure 16) suggests that attempts to further optimize the revision model can backfire, degrading sequential revision performance, which indicates the revision training approach is fragile in ways the paper does not fully understand.

Single Benchmark (MATH) and Single Model Family (PaLM 2-S*) — All Findings Are Unproven Outside Math Reasoning

The assumption or constraint. Every experiment in the paper uses the MATH benchmark (Hendrycks et al., 2021) with PaLM 2-S* as the base model. The test set consists of 500 competition-level math problems. The paper's claims about difficulty-dependent optimal strategies, the 4× efficiency gain, the superiority of beam search on medium problems and best-of-N on easy problems, and the FLOPs-matched comparison against a ~14× larger model are all established exclusively within this single benchmark and single model family.

The consequence. The paper cannot establish whether its findings are specific to math reasoning or generalize to other domains. MATH problems have several properties that may not hold in other settings:

Deterministic ground truth: every problem has exactly one correct answer that can be verified perfectly. This enables oracle difficulty estimation, PRM training via Monte Carlo rollout correctness checking, and unambiguous evaluation. Tasks with subjective, multi-dimensional, or ambiguous quality criteria (code generation where multiple implementations are valid, creative writing, dialogue) cannot use the same framework without fundamentally different verifier training approaches.
Step-by-step reasoning structure: math solutions are naturally decomposable into sequential steps with clear correctness criteria. This makes process reward modeling feasible and beam search natural. Tasks without clear step structure (summarization, translation, open-ended QA) may not benefit from step-level search.
PaLM 2-S*'s specific properties: the model's calibration, error patterns, in-context learning ability, and output distribution all affect the PRM's quality, the revision model's learning dynamics, and the difficulty-dependent scaling curves. A model with different properties (e.g., better calibrated but less creative, or stronger at math but weaker at general reasoning) might show qualitatively different difficulty-dependent behavior.

The paper's authors acknowledge the limited scope but frame it optimistically:

"We believe this model is representative of the capabilities of many contemporary LLMs" (Section 4)

This belief is untested. The paper provides no evidence that PaLM 2-S* is "representative" in the specific ways that matter for test-time compute scaling — verifier trainability, revision learning capacity, difficulty distribution shape, and search algorithm efficacy.

What evidence exists in the paper. All evidence is from the MATH benchmark. The paper does not include any experiments on other benchmarks (e.g., GSM8K, MMLU, HumanEval, ARC) or other model families. The 500-question test set, when split into five difficulty quintiles (~100 questions each) and further split by two-fold cross-validation (~50 questions per fold), means the compute-optimal policy is selected based on very small sample sizes. The paper does not report confidence intervals, so we cannot assess whether the observed strategy selections (e.g., "use beam search on bin 3") would replicate on a different 500-question sample from MATH, let alone on a different benchmark.

Mitigation status. The paper does not attempt to mitigate this limitation. It frames the work as a systematic study of test-time compute scaling — a framing that implicitly claims some generality — but provides no cross-domain or cross-model validation. This is perhaps the most significant limitation of the paper as a general framework for test-time compute scaling, as opposed to a case study on MATH with PaLM 2-S*.

The FLOPs-Matched Comparison Uses a Weak Pretraining Baseline — Parameter-Only Scaling Without Test-Time Compute

The assumption or constraint. The FLOPs-matched comparison in Section 7 compares PaLM 2-S* with compute-optimal test-time strategies against a model with approximately 14× more parameters. The larger model uses greedy decoding only — no majority voting, no best-of-N, no beam search, no revisions. Furthermore, the larger model is trained by scaling parameters while keeping training data fixed, following the LLaMA paradigm (Touvron et al., 2023) rather than compute-optimal pretraining where both data and parameters scale (Hoffmann et al., 2022). The paper acknowledges this explicitly:

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work." (Section 7)

The consequence. Both of these choices bias the comparison in favor of test-time compute. The larger model's greedy decoding means it gets no benefit from its own test-time compute budget — the comparison is essentially "small model with smart test-time compute vs. large model with no test-time compute." A fairer comparison would give the larger model some test-time compute budget (even a modest best-of-8 or majority voting over 16 samples), since in practice, anyone deploying the larger model could also apply test-time compute strategies. The paper's reported advantages of test-time compute over pretraining (e.g., +27.8% relative improvement on easy-medium questions at R ≪ 1 for revisions) may substantially shrink or reverse against a larger model that also uses test-time compute.

The parameter-only scaling (rather than Chinchilla-optimal parameter+data scaling) means the 14× larger model may be undertrained relative to a compute-optimally trained model with the same total FLOPs. An undertrained larger model underperforms its potential, making test-time compute look more favorable by comparison. The paper doesn't quantify how much of the reported advantage is due to this baseline weakness versus genuine superiority of test-time compute.

What evidence exists in the paper. The FLOPs-matched results are in Figure 9 and the bar charts in Figure 1 (top-right and bottom-right). The stars in Figure 9 representing the larger model's performance are placed at three x-axis positions corresponding to three R values (0.16, 0.79, 22). When the compute-optimal scaling line is above the star, test-time compute "wins." The paper acknowledges both limitations:

On greedy decoding: the larger model is described as using "greedy decoding, no extra test-time compute" (Section 7), but this is stated as a procedural detail, not analyzed as a limitation.
On Chinchilla-optimal scaling: quoted above (Section 7).

Mitigation status. The paper acknowledges the parameter-only scaling limitation and delegates it to future work. The greedy-decoding limitation is not discussed as a limitation at all — it's simply the described methodology. No experiments explore what happens if the larger model is also given test-time compute (e.g., best-of-N with its own verifier). This is a significant gap because it means the headline finding — "test-time compute can substitute for pretraining" — is only demonstrated under an asymmetric comparison that no practitioner would accept as a fair fight.

The Revision Model and PRM Search Are Studied Independently — Not Combined

The assumption or constraint. The paper studies two complementary mechanisms for test-time compute — revisions (modifying the proposal distribution) and PRM-guided search (modifying the verifier/selection process) — as separate scaling analyses. The compute-optimal policies are computed separately for the search axis and the revision axis, and the evaluations never combine them. The paper explicitly acknowledges this gap:

"we did not experiment with PRM tree-search techniques in combination with revisions" (Section 8)

The consequence. The paper cannot answer what is arguably the most natural next question: what happens when you apply beam search to the revision model's outputs, or use the PRM to guide which revisions to pursue? The two mechanisms address different aspects of generation: revisions improve the quality of individual candidate solutions by iterating, while PRM search improves the selection among candidates by scoring and filtering. In principle, they should be complementary — revisions produce better candidates, and search finds the best among them more efficiently than random sampling. The paper's results represent a lower bound on what combined approaches could achieve.

This is a practical limitation: a deployer who implements the full paper would need to choose between "use revisions" or "use search" rather than "use both," and the paper provides no guidance on which to prefer when both are available. The difficulty-dependent optimal strategies (revisions for easy problems, beam search for medium problems) suggest that combining them — perhaps revisions for local refinement with beam search for global exploration — could outperform either alone, particularly on medium-difficulty problems where both mechanisms show some benefit individually.

A deeper consequence: without a combined analysis, the paper cannot validate whether the difficulty-dependent strategy selection (easy → best-of-N, medium → beam search, etc.) is actually optimal when both mechanisms are available. It could be that beam search over revision model outputs dominates all single-mechanism strategies across all difficulty levels, which would simplify the compute-optimal policy but would not be discoverable from the current experiments.

What evidence exists in the paper. The evidence is purely indirect. The search analysis (Section 5) uses the base PaLM 2-S* model as the proposal distribution. The revision analysis (Section 6) uses majority voting or a separate ORM trained on revision outputs for answer selection — not the PRM-based search algorithms studied in Section 5. The paper notes that the base-LM PRM does not transfer well to revision model outputs due to distribution shift (Figure 15a, Appendix J), which is exactly the kind of integration challenge that a combined approach would need to solve. The separate revision-specific ORM trained in Section 6 is a step toward integration, but it's used only for best-of-N weighted selection, not for beam search or lookahead search.

Mitigation status. The paper delegates this to future work in Section 8. No partial combination is attempted — not even a simple experiment like "run best-of-N weighted with the revision model on a sample of prompts and compare to both standalone baselines." This is understandable given scope constraints, but it means the paper's primary practical recommendations (use revisions for easy problems, beam search for medium problems) may be premature — they don't account for the possibility that revisions + search together changes the difficulty-dependent optimal strategy landscape.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not introduce a new paradigm for video generation — flow matching, diffusion transformers, cascaded super-resolution, and sparse attention are all established techniques. What it introduces is an engineering existence proof: a demonstration that a carefully designed 8.3B-parameter monolithic DiT, trained with the right data curriculum, attention mechanism, text encoding strategy, and post-training pipeline, can match or exceed a 27B-total/14B-activated MoE model (Wan2.2) in human preference evaluations while fitting within the memory constraints of a consumer GPU. The significance is not "we invented X" but rather "we showed that the dominant quality-vs-efficiency framing is false, and we documented exactly how to achieve both."

This shifts the field's conversation from parameter-count competition toward architectural precision as the primary lever for video generation quality. Before this work, the default assumption — codified in Wan2.2's two-tier approach (27B MoE for quality, 5B compressed variant for accessibility) — was that quality and efficiency are in tension, and you must choose. HunyuanVideo 1.5 demonstrates that a single 8.3B model can occupy both positions simultaneously: competitive with Wan2.2's quality tier while matching or exceeding its accessibility tier. The 17.12% GSB win rate over Wan2.2 in T2V (Table 5) with roughly one-third the activated parameters is the headline number, but the deeper implication is that the residual quality gap between open-source and proprietary models is not primarily a parameter count gap — it's an engineering gap. Proprietary systems like Veo3 and Kling2.5 likely benefit as much from training data scale, caption quality, and post-training investment as from raw model capacity. The paper demonstrates that with the right engineering investment, a compact open-source model can close much of that gap.

The paper also provides an implicit reconciliation of conflicting design philosophies in the video generation space. MoE architectures (Wan2.2, and in different forms, many proprietary systems) optimize for specialization — different experts handle different denoising stages or different visual concepts. Monolithic architectures (HunyuanVideo 1.5, Sora's reported design) optimize for unified representation — a single model learns all aspects of video generation through conditioning signals and training curriculum. Prior to this work, there was no clear evidence that the monolithic approach could match the quality of a well-tuned MoE at similar (or in this case, substantially lower) parameter counts. The paper's results suggest that expert specialization through architecture may be less important than expert specialization through training data and conditioning — the unified DiT, through multi-task training (1:6:3 T2I:T2V:I2V ratio), progressive spatiotemporal scaling, and task-specific post-training, effectively learns specialized behaviors without the parameter overhead and coordination costs of explicit expert routing. This is not a definitive victory for monolithic approaches — Wan2.2 is one particular MoE implementation, and future MoE designs might close the gap — but it demonstrates that monolithic designs are viable at the quality frontier, which was not obvious before.

A more subtle conceptual shift concerns how the field thinks about motion quality assessment. The paper's finding that existing reward models "struggle to effectively differentiate fine-grained motion quality" (Section 4.2) led to a hybrid offline-DPO-then-online-RL strategy that decomposes alignment into motion quality (requiring human preference annotations via DPO) and visual quality/text alignment (amenable to automated reward models). This is not a methodological innovation per se — DPO and RLHF are both well-established — but it is a diagnostic that changes how practitioners should think about aligning video models. The implicit claim is that fully automated RLHF (reward-model-only optimization) will systematically underperform on motion quality because the reward signal is blind to the dimension that most distinguishes good video generation from good image generation. If this finding generalizes — and the paper doesn't prove it does, since it's based on one specific reward model architecture — it would mean that some amount of human preference data is strictly necessary for video alignment, which has significant implications for the economics of building video generation systems.

Finally, the paper's open-source release — code, weights, and a detailed technical report with specific hyperparameters (Table 1, Table 2, optimizer configuration, data volumes, task mixing ratios) — represents a concrete intervention in the research ecosystem. Proprietary video generation models reveal essentially nothing about their internals, making systematic study impossible. HunyuanVideo 1.5 provides a reference architecture that other researchers can modify, ablate, fine-tune, and build upon. This enables research directions that were previously infeasible: studying failure modes of video diffusion models at scale, developing improved sparse attention mechanisms with a strong baseline, experimenting with alternative text encoding strategies, and investigating the scaling properties of video DiTs across different parameter counts — all with a model that is actually competitive with the proprietary frontier. The paper doesn't frame this as a "contribution" in the traditional sense, but it is arguably the most impactful aspect of the work for the research community.

Follow-Up Research This Work Enables

Systematic quality comparison of SSTA vs. full attention across the sparsity-quality Pareto frontier. The paper demonstrates SSTA's speedup (1.87× on 241-frame 720p, Table 7) but never compares the quality of SSTA-generated videos to full-attention-generated videos at the same resolution, prompt, and seed. A controlled experiment would generate the GSB benchmark's 300 T2V prompts with and without SSTA, compute the GSB win rate between the two conditions, and sweep SSTA's hyperparameters (top-k, window size, λ/β weights) to trace out a speed-quality tradeoff curve. The key question: is the 1.87× speedup truly "free" in quality terms, or does it come with a measurable degradation in structural stability or motion coherence? If SSTA introduces even a 2–3 percentage point degradation in win rate, the practical deployment decision becomes a speed-quality tradeoff that the paper currently doesn't characterize. This experiment is straightforward given the released code and weights, requires no additional training, and would directly address the paper's most significant missing evaluation.

Human preference annotation budget required for motion quality alignment. The paper's T2V RLHF pipeline uses offline DPO on an O(10K) manually annotated prompt set to address motion quality, then online RL for visual quality. This raises a specific resource question that the paper doesn't answer: what is the minimum viable human annotation budget for acceptable motion quality? A follow-up study would train T2V alignment models using DPO with varying annotation budgets (1K, 5K, 10K, 50K annotated pairs) and measure the marginal improvement in motion effects Rating scores (Table 3) and GSB win rates (Table 5) per annotation dollar. This would tell practitioners whether they need to invest in large-scale human annotation or whether a small carefully-curated set suffices. The experiment is newly tractable because the paper provides a strong open-source base model, a documented DPO training recipe, and a validated evaluation framework — a researcher can start from the released HunyuanVideo 1.5 checkpoint and re-run portions of the post-training pipeline with controlled annotation budgets.

Scaling laws for video DiT parameter count at fixed training compute. The paper demonstrates that 8.3B parameters with the right architecture beats 27B/14B MoE, but doesn't characterize the quality-parameter scaling curve for its own architecture. A scaling study would train HunyuanVideo-style DiTs at 2B, 4B, 8.3B, and (if resources permit) 16B parameters, using the same training data and curriculum (Table 2) but with proportionally adjusted model dimensions and training durations to match total compute. The goal is to determine whether 8.3B is near the knee of the scaling curve (beyond which additional parameters yield diminishing returns at fixed training data scale), or whether a 16B monolithic DiT with the same design choices would substantially outperform both the 8.3B model and Wan2.2's 14B-activated MoE by a wide margin. The paper's efficient architecture and released training recipe make this more feasible than prior work — a team with access to the disclosed data volumes (5B images, 800M video clips) could run this study, using the 8.3B model as a calibrated reference point. The result would clarify whether the paper's efficiency gains are primarily about parameter count or about architecture, and would guide future open-source efforts on whether to scale up or refine the existing scale.

Glyph-aware text rendering ablation with controlled bilingual prompt sets. The paper claims that the dual-channel Qwen2.5-VL + Glyph-ByT5 encoding enables "enhanced bilingual understanding" and "accurate text rendering," but provides no evaluation isolating these capabilities. A targeted follow-up would construct a benchmark of 200–500 prompts specifically designed to test text rendering (e.g., "a sign that says 'Welcome' in English and '欢迎' in Chinese," "a book cover with the title 'Machine Learning' in gold letters," videos that require legible text at various scales and orientations) and compare the full model against an ablated variant using Qwen2.5-VL only (no Glyph-ByT5), evaluated by both automated OCR accuracy on generated video frames and human judgment of text legibility. This experiment is enabled by the paper's open-source release — the architecture supports removing Glyph-ByT5 — and would either validate a claimed contribution or reveal that text rendering improvements are driven more by training data than by the glyph encoder. The paper's strong Instruction following score (61.57, Table 3) might partially reflect text rendering capability, but without this ablation it's impossible to attribute.

Integration of SSTA-like redundancy-penalized selection into other sparse attention domains. The SSTA importance score — λ × query-key similarity minus β × key-key redundancy — is a general mechanism for block-sparse attention that is not specific to video generation. The conceptual insight (penalizing redundant selections to maximize information coverage) could apply to long-context language models, high-resolution image generation, or multi-modal transformers processing long documents. A cross-domain study would implement the SSTA scoring formula in a language model (e.g., for long-document summarization or retrieval-augmented generation where attention must cover diverse evidence) or in a high-resolution image diffusion model, and compare it against standard top-k sparse attention on both speed and task-specific quality metrics. The paper provides the algorithmic specification (Algorithm 1) and the open-source flex-block-attn CUDA kernel (Peng et al., 2025), making replication straightforward. Demonstrating that the redundancy penalty generalizes beyond video would elevate SSTA from a video-specific engineering trick to a broadly applicable sparse attention principle.

Failure mode characterization: when does SSTA drop semantically critical tokens? The paper asserts that SSTA "more effectively preserves output quality" by combining local window and global selection, but provides no analysis of what information the sparse mask actually discards. A diagnostic study would instrument SSTA to log which spatiotemporal blocks are pruned for representative prompts (varying in motion complexity, scene type, and duration), then analyze whether pruned blocks correspond to semantically important but statistically atypical regions (e.g., small fast-moving objects, rare visual elements, text regions that are unlike background textures). This would reveal whether SSTA has systematic failure modes — specific types of video content where the redundancy penalty mistakenly discards blocks that are visually distinctive but appear "redundant" by key-similarity statistics. The experiment is enabled by the released model and the parameter-free nature of SSTA (no training needed to probe mask patterns). Finding and characterizing failure modes would guide improvements to the scoring formula (e.g., adding a "motion salience" term or adjusting λ/β for specific content types) and would inform practitioners about what video content might degrade under SSTA.

Practical Applications and Downstream Use Cases

Consumer-grade video creation tools for individual creators and small studios. The paper's headline deployment number — 13.6 GB peak GPU memory for 720p 121-frame T2V/I2V generation on a single GPU (Section 6) — means that a creator with an RTX 4090 (24 GB, currently available for ~$1,600) can run a model competitive with proprietary systems like Kling2.1 Master (GSB win rate +12.60%, Table 5) locally, without API costs, latency, or privacy concerns. This enables use cases that were previously infeasible: iterative prototyping of video concepts (generate, review, adjust prompt, regenerate — all locally without per-generation fees), generation of content that cannot be sent to external APIs for privacy or copyright reasons, and fine-tuning on a creator's own video library (faces, locations, art styles) using the released weights. The 1.87× SSTA speedup on 10-second 720p synthesis (Table 7) means the iterative loop is fast enough to be practical — without SSTA, a 10-second clip might take ~275 seconds per generation (50 steps × 5.5s/step), which is barely tolerable for interactive use; with SSTA and engineering acceleration, it drops to ~58 seconds (Table 8), making rapid experimentation viable.

Batch video asset generation for game development and synthetic data. For game studios generating thousands of environment videos, character animation references, or cutscene drafts, or for computer vision teams generating synthetic training data (e.g., diverse driving scenes, human activity clips), the open-source nature and consumer-GPU compatibility are transformative. A studio can deploy HunyuanVideo 1.5 across a farm of RTX 4090-class GPUs without per-unit licensing costs. The model's strong Structural stability (79.75, the highest in Table 3 across all models including Veo3) is particularly valuable for synthetic data — temporally coherent videos with minimal frame-to-frame artifacts are essential for training downstream vision models that might otherwise overfit to generation artifacts. The progressive training curriculum (Table 2) that produces models at 480p and 720p gives studios flexibility: generate large volumes of 480p assets quickly for initial prototyping, then use the VSR network to upscale selected clips to 1080p with enhanced detail (Table 4, 480pSR vs. 720p comparison shows structural stability improves from 66.67 to 70.13 through super-resolution).

Bilingual content localization at scale. The combination of Qwen2.5-VL for semantic understanding and Glyph-ByT5 for character-level text encoding makes HunyuanVideo 1.5 uniquely positioned for generating videos that contain legible, correctly-spelled text in Chinese, English, or mixed scripts. For global marketing teams, educational content producers, or social media creators serving bilingual audiences, this means generating a single video concept with prompt text in both languages and having the model render text accurately rather than producing garbled characters (a known failure mode of most video generation models). While the paper doesn't quantify text-rendering accuracy directly, the strong Instruction following score (61.57 in T2V, 63.05 in I2V, both best or near-best among non-Veo3 models in Tables 3-4) and the explicit architectural investment in glyph encoding suggest this capability is real and deployment-ready. The consumer-GPU requirement means a localization team in a small office can run the model on existing hardware rather than depending on cloud APIs that may not support the required language pairs or may introduce unacceptable latency.

When to Prefer This Method

The paper positions HunyuanVideo 1.5 against specific named alternatives — Wan2.2 (open-source MoE, 27B/14B), Kling2.1 Master, Seedance Pro, and Veo3 (proprietary) — and its design choices reflect explicit tradeoffs against these systems. The decision framework is:

Prefer HunyuanVideo 1.5 when:

Deployment hardware is consumer-grade GPUs (≤24 GB VRAM). The 13.6 GB peak memory for 720p generation (Section 6) makes it the only model in the comparison set confirmed to run on an RTX 4090. Wan2.2's 27B total parameters likely require datacenter GPUs, and proprietary systems are API-only. If local deployment is a hard constraint, the choice is effectively forced.
Instruction following and structural stability are the priority dimensions. In T2V Rating (Table 3), HunyuanVideo 1.5 leads all non-Veo3 models on Instruction following (61.57) and all models including Veo3 on Structural stability (79.75). For applications where temporal coherence and prompt adherence matter more than pure aesthetic beauty — educational content, instructional videos, synthetic data generation — HunyuanVideo 1.5 is the best-documented option.
Bilingual (Chinese-English) text rendering is required. No competitor in the evaluation set is described as having a dedicated glyph-aware text encoder. If generating videos with accurate, legible text in multiple scripts is a requirement, the Glyph-ByT5 integration is a differentiating feature that may not exist in alternatives.
Open-source modification, fine-tuning, or research is the goal. The released code and weights enable customization that proprietary APIs prohibit and that Wan2.2 may not support (the paper does not describe Wan2.2's fine-tuning capabilities).

Prefer Veo3 (or other top-tier proprietary systems) when:

Maximum aesthetic quality and motion smoothness are the overriding concern. Veo3 leads T2V Rating on Instruction following (73.77, a dominant 12-point margin over HunyuanVideo 1.5) and Motion effects (60.81), and has a positive 10.32% GSB win rate over HunyuanVideo 1.5 (Table 5). If quality is the only metric and API access is acceptable, Veo3 is the stronger choice.
Image-to-video with maximum image consistency is required. Seedance Pro and Wan2.2 both outperform HunyuanVideo 1.5 on Image consistency in I2V Rating (73.06 and 73.53 vs. 72.07, Table 4), and the I2V GSB win rates are negative against both Seedance Pro (−5.77%) and Veo3 (−3.61%) (Table 6). For I2V tasks where preserving the reference image's exact appearance is critical, proprietary alternatives may have an edge.

Prefer Wan2.2 when: The paper does not identify a clear quality dimension where Wan2.2 dominates HunyuanVideo 1.5 — Wan2.2 trails in T2V GSB win rate (−17.12%), I2V GSB win rate (−12.65%), and most Rating dimensions. The only possible preference for Wan2.2 would be if its MoE architecture enables specific fine-tuning or adaptation capabilities not supported by HunyuanVideo 1.5's monolithic design, but the paper provides no evidence either way on this point.