ArXiv: 2605.15178

🎯 Pitch

Forget massive clusters—SANA-WM generates a full minute of 720p video from a single image and a camera path on just one GPU. A distilled version runs in 34 seconds on a consumer RTX 5090, yet it matches the visual quality of industrial systems that demand multi-GPU inference, thanks to a hybrid linear attention backbone that makes minute-scale context affordable.

1. Executive Summary

SANA-WM introduces an efficient 2.6B-parameter open-source world model natively trained for one-minute, 720p video generation with precise 6-DoF camera control. The system combines four named mechanisms: Hybrid Linear Attention (interleaving frame-wise Gated DeltaNet blocks with periodic softmax attention for memory-efficient long-context modeling), Dual-Branch Camera Control (a latent-rate UCPE branch for global trajectory structure plus a raw-frame Plücker mixing branch for fine motion within each temporal VAE stride), a Two-Stage Generation Pipeline (a dedicated long-video refiner applied to stage-1 outputs to correct artifacts and sharpen details across the full minute), and a Robust Annotation Pipeline (recovering metric-scale camera poses from public videos via Pi3X and MoGe-2 depth estimators). Trained on only ~213K public video clips in 15 days on 64 H100 GPUs, SANA-WM achieves stronger action-following accuracy than prior open-source baselines while delivering up to 36× higher generation throughput—its distilled variant denoises a 60-second 720p clip in 34 seconds on a single RTX 5090 with NVFP4 quantization—establishing that minute-scale, camera-controlled world modeling with high visual fidelity is achievable under accessible compute budgets only when efficiency is treated as a first-class architectural objective from the outset.

2. Context and Motivation

The Core Problem: Making Long-Horizon Camera-Controlled World Models Practical

The fundamental gap this paper addresses is that minute-scale, 720p, camera-controlled world models exist, but they are inaccessible to most researchers and practitioners because they require massive models, enormous training datasets, multi-GPU inference, and extended training schedules. SANA-WM asks a concrete, testable question: can we natively train a high-fidelity, camera-controllable, one-minute world model while keeping data, training, and inference costs accessible? The answer matters because world models are increasingly positioned as foundational infrastructure for embodied simulation, robotics, and interactive environments, yet their resource requirements effectively exclude all but the largest industrial labs from participating in their development and use.

A world model in this context is a generative system that, given a first video frame, a text description, and a 6-DoF camera trajectory (position and orientation over time), synthesizes a video following that trajectory while preserving the scene's identity, layout, and visual appearance. Think of it as a controllable camera simulator: you describe a scene, you specify where the camera moves over the next minute, and the model generates what the camera would see. This capability is directly useful for generating training data for embodied agents (synthetic visual experience), prototyping interactive environments, evaluating long-horizon scene understanding systems, and enabling research on persistent 3D scene memory without requiring physically captured video.

Why This Problem Is Important

The paper motivates the importance of efficient world modeling along several dimensions that span practical deployment, research democratization, and the structure of the field:

Democratizing access to world-model research. The authors explicitly frame accessibility as a first-class objective (Section 1). Recent open-source world models that achieve minute-scale, action-conditioned rollouts—they cite HY-WorldPlay, LingBot-World, and Infinite-World as examples—typically require large models (5B–14B+ parameters), large-scale proprietary or hard-to-replicate datasets, training schedules measured in weeks or months, and multi-GPU inference setups. A lab without access to hundreds of GPUs simply cannot train, evaluate, or even run inference with these systems. By demonstrating that a 2.6B model trained on ~213K public clips in 15 days on 64 H100s can match or exceed their action-following accuracy at 720p with single-GPU inference, SANA-WM lowers the barrier to entry dramatically. This is not merely a "smaller is faster" observation—it requires a specific set of architectural decisions (hybrid attention, dual-branch camera control, high-compression latents) that are individually motivated by the efficiency constraint.

Enabling real-time and interactive applications. The inference efficiency path (distilled variant on a single RTX 5090 producing a 60-second 720p clip in 34 seconds, Section 5.4, Figure 7a) is targeted at interactive use cases. If a world model requires multiple high-end GPUs and minutes of compute per rollout, it cannot serve as a real-time simulator for embodied agents, game engines, or robotics training loops. The paper explicitly contrasts with baselines like LingBot-World, which supports 720p generation but requires 8 GPUs (454.1 GB peak memory in the evaluation, Table 2), making minute-long 720p inference unaffordable under the paper's 8-H100 evaluation budget. The efficiency is not an afterthought—it is what makes certain downstream use cases possible at all.

Resolving a tension between short-horizon distillation and native long-horizon training. The paper identifies a tempting but insufficient shortcut (Section 1): distilling long-rollout models from short-video generators. The problem is that short-horizon teachers provide limited supervision for minute-scale scene persistence and trajectory following. A model trained on 5-second clips cannot teach a student how to maintain coherent geometry, object identity, and lighting over 60 seconds of camera motion, because the teacher never learned these things itself. The paper argues that native minute-scale training is necessary for genuine long-horizon capability, and the question becomes whether native training can be made efficient enough to be practical.

Establishing a benchmark and evaluation protocol for minute-scale world modeling. The field lacks standardized evaluation for long-horizon camera-controlled generation (Section 5.2). Existing benchmarks target short-video quality or single-frame camera accuracy, but not the combination of minute-scale persistence, revisit memory (does the scene look consistent when the camera returns to a previous viewpoint?), and action-following accuracy under aggressive trajectories. The paper constructs a benchmark with 80 initial scenes across four categories, each paired with simple and hard revisit trajectories, and defines metrics for camera control accuracy, visual quality, revisit memory, and temporal degradation. This fills a genuine gap: without a shared benchmark, comparing world models across papers is impossible.

Where Prior Approaches Fall Short

The paper identifies specific limitations across several categories of prior work, each contributing to the resource-accessibility problem it targets.

Training Data Scale and Annotation Cost

Prior camera-controlled world models rely on data at scales and quality levels that are difficult to replicate. The paper notes that existing systems "typically require large models, large-scale data, long training schedules, and multi-GPU inference" (Section 1). While the paper does not specify the exact dataset sizes of its baselines, the implication is clear: HY-WorldPlay, LingBot-World, and Matrix-Game 3.0 were trained on substantially larger or more curated datasets (likely including proprietary data or expensive human annotations). SANA-WM's data pipeline (Section 4) is explicitly designed to recover metric-scale camera poses from public videos without human labels, using only pose estimators (VIPE, Pi3X, MoGe-2). The ~213K clips it produces represent a deliberate efficiency target: enough data to train a capable model, but not so much that the pipeline becomes inaccessible.

The annotation challenge specifically involves metric-scale pose recovery from internet video. Generic SLAM or structure-from-motion pipelines produce poses up to an unknown scale factor. For camera-controlled world modeling, metric scale matters because the model needs to interpret and reproduce absolute motion magnitudes. The paper's annotation pipeline (Section 4, Appendix B.1) replaces the original VIPE depth estimator with Pi3X (for long-sequence-consistent 3D structure) and MoGe-2 (for accurate per-frame metric scale), fusing them by solving for per-frame scale factors. This is a non-trivial engineering contribution that makes public video usable for metric-pose training, but the prior reliance on expensive or proprietary pipelines meant that most groups could not produce training data of comparable quality.

Architectural Inefficiency for Long-Context Video Modeling

Standard softmax attention scales quadratically with sequence length. For a one-minute video at 720p resolution, even with aggressive spatial compression, the number of visual tokens is enormous. The paper uses LTX2 VAE latents: 128-channel compressed representations with 2.0× better compression than ST-DC-AE and 8.0× better than Wan2.1-VAE (Section 3.1, Stage 1). But even after compression, a 60-second video requires processing ~961 latent frames with hundreds of spatial tokens each. The paper's Figure 7b shows that an all-softmax variant runs out of H100 memory at 60 seconds, even with matched resolution and camera conditioning. This means that standard DiT architectures with full softmax attention are fundamentally incapable of processing minute-scale video on a single GPU, regardless of how well they are optimized.

Cumulative linear attention (the SANA-Video baseline) avoids quadratic scaling but introduces drift. SANA-Video used ReLU-based cumulative linear attention (Section 3.2, Equation 1), which accumulates key-value outer products into a fixed-size recurrent state. This keeps memory constant with respect to context length—a critical property for long videos. However, the paper identifies a specific failure mode at the minute scale: the cumulative state has no explicit decay or saliency mechanism. Stale features from the distant past accumulate with the same effective weight as recent ones, causing drift and degrading training stability. This is not a minor issue—at 961 frames, the unbounded growing state causes training to become unstable. The paper uses the frame-wise Gated DeltaNet to address this, but the cumulative linear attention limitation explains why simply using SANA-Video's architecture at longer sequences is insufficient.

The tension between efficiency and long-range recall. Linear attention and recurrent models are memory-efficient but sacrifice the ability to attend precisely to arbitrary past tokens—a capability that softmax attention provides natively. For world modeling, exact long-range recall matters: the model needs to remember the color of a distant building, the layout of a room entered 30 seconds ago, or the texture of a surface seen briefly through a window. The paper's hybrid design (15 GDN blocks + 5 softmax blocks interleaved at layers {3, 7, 11, 15, 19}, Section 5.1) is a direct response to this tension. By placing softmax attention at periodic intervals, the model can anchor long-term spatial consistency while using efficient GDN blocks for frame-by-frame evolution. The paper does not claim this is the first hybrid architecture—it explicitly cites prior hybrid designs in language modeling (Qwen3, Kimi Linear, Kimi K2, Section 2)—but it is the first to apply this principle to minute-scale video generation with camera control.

Camera Control: Coarse Conditioning Misses Intra-Stride Motion

The paper identifies a subtle but important limitation in how prior work conditions video generation on camera poses. Most approaches inject camera information at the latent frame rate, which is the natural rate of the compressed representation. However, the LTX2 VAE compresses 8 raw video frames into one latent frame through its temporal stride. This means that distinct camera poses for each of those 8 raw frames get collapsed into a single latent representation. Conditioning only at the latent rate effectively tells the model "the camera is somewhere in this neighborhood" rather than providing the precise per-raw-frame trajectory.

The dual-branch design addresses this directly (Section 3.3): the UCPE branch operates at the latent rate and captures global trajectory structure using ray-local coordinate transforms, while the Plücker mixing branch injects raw-frame-level geometric information (pixel-wise Plücker raymaps from each of the 8 raw frames) immediately after each self-attention output. The Plücker representation encodes both ray direction and moment (direction × origin), providing a complete geometric description of each pixel's viewing ray in world coordinates. By injecting this at the raw-frame rate, the model can recover fine camera motion inside each VAE stride, which would otherwise be lost to the compression. The ablation in Table 4 confirms that Plücker-only conditioning gives only small gains over no control, while UCPE provides the bulk of the improvement, and the combination yields the lowest pose errors—suggesting the two branches play complementary roles.

Visual Quality Degradation Under Limited Data and Compute

The paper acknowledges a pragmatic reality: when a base generator is trained under limited data and compute (213K clips, 64 GPUs, 15 days), its visual fidelity will not match that of models trained on orders of magnitude more data. Rather than scaling up training (which would violate the efficiency constraint), SANA-WM uses a dedicated second-stage refiner (Section 3.4). The refiner is not merely a generic upscaler or deblurring module—it is trained specifically on the distribution gap between SANA-WM's stage-1 outputs and high-fidelity targets, using truncated-σ flow matching (where the source is a degraded latent perturbed with large noise, and the target is the high-quality latent). The refiner is initialized from the 17B LTX-2 model and fine-tuned with LoRA adapters, keeping the additional cost manageable.

A key ablation in Appendix A (Table 5) demonstrates why a general-purpose refiner is insufficient: applying the original LTX-2.3 refiner directly to 60-second SANA-WM latents substantially reduces perceptual quality (VBench Overall drops from 80.62 to 71.37 on the Simple split), degrades late-window imaging quality (IQ50–60 drops from 72.21 to 35.70), and worsens camera control accuracy (RotErr increases from 4.50° to 8.65°). The adapted long-video refiner is therefore not a cosmetic add-on but a necessary component for making the two-stage pipeline work at the minute scale.

Lack of Standardized Evaluation for Minute-Scale World Models

The paper constructs its own benchmark (Section 5.2, Appendix D) because existing evaluation suites do not target the specific challenges of minute-scale camera-controlled generation. Standard video quality metrics (FVD, VBench) measure per-clip quality but do not assess whether a model preserves scene identity under loop closures. Camera accuracy metrics exist (recovered pose vs. ground truth) but are typically evaluated on short clips where drift is less severe. The paper's benchmark introduces:

  • Revisit pairs: pre-identified frames where the camera returns to nearly the same viewpoint (position < 0.5 m, viewing angle < 20°), enabling measurement of scene memory via PSNR/SSIM/LPIPS.
  • Temporal degradation (ΔIQ): the drop in VBench imaging quality between the first and last 10-second windows of a 60-second video, quantifying long-horizon visual drift.
  • Hard vs. Simple trajectory splits: the Hard split includes loops, crossings, vertical motion, whip pans, and double loops that stress-test scene persistence and action following beyond smooth navigation.

Without such a benchmark, prior work could not be compared systematically on the dimensions that matter most for world models, and the field lacked a shared definition of what "good" long-horizon performance means.

How This Paper Positions Itself Relative to Existing Work

The paper situates itself within a specific lineage of efficient video generation and interactive world modeling, while distinguishing its contributions along four axes.

From efficient image/video generation to efficient world modeling. SANA-WM directly builds on SANA-Video, which introduced linear attention backbones for efficient video diffusion generation. The paper is explicit about this inheritance: it starts from the SANA-Video architecture and progressively replaces components (VAE, attention mechanism, camera conditioning) to adapt it for minute-scale world modeling (Section 3.1, the four-stage progressive training strategy). This positions SANA-WM not as a from-scratch design but as a systematic adaptation of efficient generation techniques to the world-modeling setting. The key insight is that world modeling imposes additional constraints (long-horizon consistency, precise action following, scene memory) that generic efficient video generation does not address.

Native minute-scale training vs. autoregressive extension. The paper draws a sharp distinction between models that are natively trained on long sequences and those that achieve long rollouts through autoregressive or block-wise extension of short-context models (Section 2). The argument is that short-horizon teachers cannot provide adequate supervision for minute-scale scene persistence. SANA-WM is natively trained on 961-frame (60-second) sequences in Stage 3, after architecture stabilization on shorter clips. This distinguishes it from approaches that generate long videos by stitching together independently generated segments, which the paper implies will accumulate drift and fail to maintain global consistency.

Camera control as geometry-aware conditioning, not just an extra input. The paper's dual-branch camera control design (UCPE + Plücker mixing) is positioned against simpler approaches that treat camera parameters as just another conditioning vector. UCPE applies ray-local transforms to query, key, and value vectors in the attention mechanism, making the attention operation geometrically aware—a token from a different viewpoint is compared in a coordinate system aligned with the current token's viewing ray. The Plücker mixing branch injects per-pixel geometric information at the raw-frame rate. Together, these go beyond "conditioning on pose" toward "building geometric structure into the attention computation itself." The ablation in Table 4 shows that simpler alternatives (Plücker-only, PRoPE) are substantially worse at camera control, validating this design choice.

Efficiency as a first-class objective, not an afterthought. The paper's most distinctive positioning is that efficiency is not a constraint to work around but a design principle that guides every architectural decision. The VAE choice (LTX2 for maximum compression), the attention hybrid (GDN for efficient recurrence, softmax for periodic exact recall), the camera control design (operating at both latent and raw-frame rates to avoid wasting the VAE's compression), and the two-stage pipeline (using a lightweight base model for trajectory search and a heavier refiner for final quality) are all justified primarily in terms of their efficiency properties. This contrasts with prior work where efficiency improvements are applied post-hoc to models designed for maximum quality without regard to computational cost.

Open-source and reproducible by design. The paper emphasizes that all data sources are public, the annotation pipeline uses open tools (VIPE, Pi3X, MoGe-2), and the model is open-source (Section 1). This is positioned against baselines that use proprietary data or unreleased training recipes. However, the paper is careful to document the license and terms status of all external assets in Table 11 (Appendix G), acknowledging that some sources have non-commercial or custom terms that may restrict certain uses. This transparency about licensing is itself a form of positioning: SANA-WM aims to be practically reproducible for academic and research use cases, even if full commercial deployment requires navigating the terms of its data sources.

The Specific Gap This Paper Fills

Synthesizing these observations, the gap SANA-WM fills is: no existing open-source system simultaneously achieves (a) native minute-scale training, (b) 720p output, (c) precise 6-DoF camera control with metric-scale accuracy, and (d) single-GPU inference, while (e) being trainable on public data with a consumer-scale GPU cluster in two weeks. Each prior system fails on at least one of these criteria:

  • LingBot-World achieves high visual quality and camera control but requires a 14B+14B parameter model, 8 GPUs for inference, and an unspecified training scale (implied to be substantially larger than SANA-WM's 213K clips).
  • HY-WorldPlay achieves long-term geometric consistency but uses an 8B model on 8 GPUs with 480p output and shows severe temporal degradation (ΔIQ of 23.59/25.88 on the Simple/Hard splits, Table 8).
  • Infinite-World achieves single-GPU inference and 1000-frame horizons but operates at 480p with weaker camera control (RotErr 16.55° on Simple, 41.31° on Hard, Table 2).
  • Matrix-Game 3.0 achieves 720p output and strong visual quality but uses a 5B model on 8 GPUs and was trained on a substantially larger proprietary dataset.
  • SANA-Video achieves efficient video generation but was not designed for camera-controlled long-horizon world modeling and uses cumulative linear attention that degrades at the minute scale.

SANA-WM's contribution is not that it outperforms all baselines on all metrics—it does not (LingBot-World has marginally higher VBench Overall in some settings)—but that it achieves competitive or superior performance while satisfying all five accessibility criteria simultaneously. The 36× throughput improvement (24.1 videos/hour on 8 H100s vs. 0.6 for LingBot-World, Table 2) is the quantitative evidence for this claim.

This gap is timely because world models are transitioning from proof-of-concept demonstrations to practical tools for simulation and embodied AI research. If the only usable systems require industrial-scale resources, the research community cannot study their failure modes, improve their architectures, or apply them to novel domains. SANA-WM explicitly aims to enable this broader participation, and the paper's detailed documentation of its architecture, training pipeline, data sources, and evaluation protocol serves that goal.

3. Technical Approach

3.1 Reader Orientation

SANA-WM is a camera‑controlled video diffusion model that, given a single image, a text description, and a 6‑DoF camera trajectory, synthesizes a 60‑second, 720p video following that trajectory. The core engineering problem it solves is: how do you build a model that can process and generate minute‑scale high‑resolution video when standard attention mechanisms consume memory that grows quadratically with sequence length — making single‑GPU inference impossible — and when aggressive video compression loses the fine camera‑motion detail needed for precise control? The solution is a set of four co‑designed architectural mechanisms (hybrid linear‑softmax attention, dual‑rate camera conditioning, a compressed latent space, and a two‑stage quality pipeline) that together make the memory, compute, and control‑accuracy constraints compatible.

3.2 Big‑Picture Architecture (Diagram in Words)

The system has five major components connected in a two‑stage pipeline:

  1. LTX2 Video VAE (Encoder/Decoder): compresses raw 720p video into a compact latent representation (128 channels, ~32× spatial and 8× temporal compression) to drastically reduce the number of tokens the diffusion model must process, and decodes latents back to pixels.
  2. SANA‑WM Diffusion Transformer (DiT) Backbone: the core 2.6B‑parameter generator. It takes text tokens, a reference first‑frame latent, camera‑pose information, and a noised latent sequence, and iteratively denoises the sequence to produce a clean latent video. Internally it uses 20 transformer blocks that interleave efficient Gated DeltaNet (GDN) recurrence with periodic exact softmax attention, plus dual‑branch camera‑conditioning modules in every block.
  3. Dual‑Branch Camera Control: a geometry‑aware conditioning subsystem with two parallel paths: a latent‑rate UCPE (Unified Camera Positional Encoding) branch that warps attention keys/queries/values into ray‑local coordinates to capture the global trajectory, and a raw‑frame Plücker‑mixing branch that injects per‑raw‑frame geometric raymaps to recover motion details lost inside the VAE temporal stride.
  4. Long‑Video Refiner (Stage 2): a separate 17B DiT model, initialized from LTX‑2 and adapted with LoRA, that takes the stage‑1 SANA‑WM latent output and a clean reference frame, and performs a truncated flow‑matching refinement pass to correct artifacts and sharpen details across the full minute‑long sequence.
  5. Pose Annotation Pipeline (offline): a preprocessing system that recovers metric‑scale 6‑DoF camera poses from public videos using a modified VIPE engine with Pi3X and MoGe‑2 depth estimators, enabling training with only publicly available data.

Information flows as follows: a text prompt, first‑frame image, and camera trajectory enter the system → the first frame is encoded by the LTX2 VAE into a reference latent → the camera trajectory is converted into UCPE ray‑local transforms (at the latent rate) and raw‑frame Plücker raymaps → a noised latent sequence is initialized → the SANA‑WM DiT backbone iteratively denoises the sequence, conditioned on text, reference latent, UCPE, and Plücker features, using hybrid GDN/softmax attention across 961 latent frames → the final clean latent is decoded by the LTX2 VAE into a stage‑1 video → optionally, the stage‑1 latent and reference frame are passed to the refiner, which performs a few‑step truncated flow‑matching denoising to produce a higher‑fidelity latent, decoded to the final output video.

3.3 Roadmap for the Deep Dive

  • First, the progressive training strategy (Section 3.1): because the full model is complex and training it end‑to‑end on minute‑scale video would be prohibitively expensive and unstable, the paper uses a four‑stage curriculum that introduces components sequentially. Understanding this curriculum is essential for understanding why each component exists and how they are validated.
  • Second, the hybrid GDN/softmax attention backbone (Section 3.2): this is the core efficiency innovation. We will start from SANA‑Video’s cumulative linear attention, explain why it fails at the minute scale, build up to frame‑wise Gated DeltaNet, derive the key‑scaling stabilization needed for spatial token explosion, and then show how interleaving periodic softmax blocks complements the recurrence.
  • Third, the dual‑branch camera control (Section 3.3): with the backbone established, we will see how camera poses are injected. The UCPE branch provides global geometric awareness in attention space, while the Plücker branch recovers intra‑stride motion lost to compression. The ablation (Table 4) shows both are necessary.
  • Fourth, the second‑stage refiner (Section 3.4): a practical quality‑improvement pass that is trained on the specific distribution gap between SANA‑WM stage‑1 outputs and high‑fidelity targets, using truncated‑σ flow matching and LoRA adaptation of a larger pretrained model.

3.4 Detailed, Sentence‑Based Technical Breakdown

This is primarily a systems and architecture paper whose core idea is that minute‑scale, camera‑controlled video generation can be made practical by (1) compressing the token sequence aggressively with a high‑compression VAE, (2) using a hybrid recurrent/attention backbone that keeps memory constant with respect to sequence length while retaining long‑range recall, (3) injecting camera control at both the latent rate (for global trajectory) and the raw‑frame rate (for intra‑stride motion), and (4) applying a dedicated long‑video refiner as a post‑processing quality boost rather than trying to achieve perfect quality in a single stage.

Progressive Training Strategy (Section 3.1)

Training a model to directly generate 961‑frame 720p latents from scratch would be extremely unstable and slow. Instead, the paper sequences architectural changes and data scaling in four stages, each building on the previous. Each stage solves a specific problem that would be too difficult to debug if all changes were introduced simultaneously.

Stage 1: Efficient VAE Adaptation. The starting point is a SANA‑Video checkpoint that uses a Wan‑based VAE. The first change replaces this VAE with the LTX2 VAE, which has a 2.0× better compression ratio than ST‑DC‑AE and 8.0× better than Wan2.1‑VAE (measured in latent channels and spatiotemporal downsampling factors). Because the channel dimension changes (LTX2 uses C=128 latent channels), the model’s input patch‑embedding layer and final output projection layer are discarded and re‑initialized from scratch; the rest of the model is fine‑tuned end‑to‑end on SANA‑Video SFT data for 50,000 steps (~3.5 days on 64 H100s, Table 7). The key property established here is that the VAE swap is quality‑neutral (Table 3: VBench‑I2V Total goes from 0.8378 to 0.8390) while cutting peak memory from 8.9 GB to 5.4 GB and reducing latency 3.4× (from 1266.6 ms to 371.7 ms per step). This is the foundation that makes minute‑scale training feasible.

Stage 2: Hybrid Architecture Adaptation. With the efficient VAE in place, the model’s internal attention mechanism is changed from cumulative linear attention to the hybrid GDN/softmax design (detailed in Section 3.2). This stage trains on 5‑second clips only, which is critical: short clips are cheaper to train, and if the architecture change introduces instability or quality regressions, they are detectable much faster. The architecture is trained for 30,000 steps (~2 days on 64 H100s). Table 3 shows this change boosts VBench‑I2V Total from 0.8390 to 0.8530, while memory increases only modestly (5.4 GB → 5.68 GB). The quality improvement comes from the periodic softmax blocks providing better long‑range dependency modeling than pure linear attention.

Stage 3: Minute‑Scale Extension and Action Conditioning. The stabilized hybrid architecture is now extended from 5‑second clips to 60‑second (961‑frame) sequences, and the dual‑branch camera control modules are added. This stage trains on the full 213K‑clip corpus with metric‑scale pose supervision for 31,000 steps (~8 days on 64 H100s). At this scale, a key efficiency optimization is used: VAE latents are precomputed offline, removing the cost of online VAE encoding during DiT training. Training uses Context Parallelism (CP) with size 2, meaning each GPU pair shares a latent sequence split along the temporal dimension. The effective global batch size is 32 (0.5 clips per GPU × 64 GPUs).

Stage 4: Chunk‑Causal Fine‑Tuning and Few‑Step Distillation. The Stage 3 model generates videos bidirectionally (attention can see all frames simultaneously). For interactive or streaming use cases, an autoregressive (AR) variant is needed. The model is fine‑tuned to be chunk‑causal: video frames are partitioned into chunks, a global forward GDN scan provides past context, and the reversed‑time GDN scan is reset at chunk boundaries so each chunk can see its local future without leaking information from later chunks. Attention‑sink tokens (the first latent frame kept permanently in the KV cache) and local temporal windows are added to softmax attention layers to keep memory and per‑chunk latency constant regardless of rollout length. The AR model is then distilled using self‑forcing distillation (Huang et al., 2025) to reduce sampling from 60 denoising steps to 4 steps. Figure 7a shows the resulting efficiency path: the 4‑step distilled AR model with NVFP4 quantization generates a 60‑second 720p clip in 34 seconds on a single RTX 5090.

Why this staged approach: The alternative — training the full hybrid architecture on minute‑scale data with camera control from scratch — would require diagnosing failures across three interacting new components (VAE, attention, camera) simultaneously. The stage‑by‑stage approach lets each change be validated independently at short sequence lengths before scaling. The cumulative property is deliberate: Stage 1 proves VAE efficiency is quality‑neutral, Stage 2 proves the hybrid backbone improves quality beyond the baseline, and Stage 3 proves the combination scales to minute‑long sequences.

Memory‑Efficient Long‑Context Modeling (Section 3.2)

This section contains the paper’s most technically dense contribution. It builds from a known efficient attention baseline, diagnoses a specific failure mode at minute scale, and constructs a stabilized recurrent alternative with periodic exact‑attention injections.

The Baseline: Cumulative Linear Attention in SANA‑Video

SANA‑Video replaced standard causal softmax attention with cumulative linear attention. For a latent frame indexed by $t$, let $Q_t, K_t, V_t \in \mathbb{R}^{D \times S}$ collect the per‑head queries, keys, and values for the $S$ spatial tokens in that frame. Using a non‑linear feature map $\phi(\cdot) = \text{ReLU}(\cdot)$, the attention output for frame $t$ is computed as:

O~tLA=AtLAϕ(Qt)=(∑τ=0tVτϕ(Kτ)⊤)ϕ(Qt)\tilde{O}_t^{\text{LA}} = A_t^{\text{LA}} \phi(Q_t) = \left( \sum_{\tau=0}^{t} V_\tau \phi(K_\tau)^\top \right) \phi(Q_t)

where $A_t^{\text{LA}} \in \mathbb{R}^{D \times D}$ is the cumulative key‑value outer‑product state, and the standard linear‑attention normalization denominator is omitted for brevity in the paper’s notation. The recurrence $A_t^{\text{LA}} = A_{t-1}^{\text{LA}} + V_t \phi(K_t)^\top$ updates a fixed‑size $D \times D$ matrix once per latent frame after aggregating all spatial tokens’ outer products.

What it computes: For each query token in frame $t$, the output is a $D$‑dimensional vector formed by first multiplying the query (after ReLU activation) by a $D \times D$ matrix that encodes the sum over all previous key‑value outer products, effectively computing a weighted sum over all past values where the weight of each past token depends on the dot‑product between its key features and the current query features (through the linearization $\phi(Q)^\top \phi(K)$). The recurrence means memory stays $O(D^2)$ regardless of sequence length.

Why this form: This avoids the $O(T^2)$ memory and compute of softmax attention by replacing the softmax kernel with a linearized approximation. The ReLU activation ensures the features are non‑negative, which helps training stability. For short videos (e.g., 5 seconds), this is both efficient and effective — the cumulative state can retain relevant information without the pairwise attention matrix.

The Failure Mode at Minute Scale

The critical limitation is that $A_t^{\text{LA}}$ has no decay: every past frame contributes equally to the cumulative sum, forever. After 961 frames, the state contains information from the first frame weighted identically to information from the 960th frame. There is no mechanism to forget stale features (e.g., a wall that was briefly visible and is now far behind the camera) or to emphasize recent context. The paper states this causes "drift and degrades training stability" at the minute scale. The unbounded accumulation also means the state magnitude grows with sequence length, which affects gradient scales.

Frame‑wise Gated DeltaNet (GDN)

Gated DeltaNet augments the recurrent state with two learned control mechanisms: a decay gate that forgets old information, and a delta‑rule update that only modifies the state in directions that are poorly predicted. The standard token‑wise GDN update (from Yang et al., 2024) is:

Si=γiSi−1+(vi−γiSi−1k^i)βik^i⊤,oi=Siq^iS_i = \gamma_i S_{i-1} + (v_i - \gamma_i S_{i-1} \hat{k}_i) \beta_i \hat{k}_i^\top, \quad o_i = S_i \hat{q}_i

where $S_i \in \mathbb{R}^{D \times D}$ is the per‑token recurrent state, $\hat{q}_i, \hat{k}_i, v_i \in \mathbb{R}^D$ are the normalized query, normalized key, and value vectors for token $i$, $\beta_i \in [0, 1]$ is an update gate (controlling how much new information enters the state), and $\gamma_i \in (0, 1]$ is a decay gate (controlling how much old information is retained). The correction term $(v_i - \gamma_i S_{i-1} \hat{k}_i)$ computes the residual between the target value and what the current state predicts, and only this residual is written into the state.

What it computes for a single token: First, the state $S_{i-1}$ is multiplied by the decay gate $\gamma_i$, forgetting a fraction $(1-\gamma_i)$ of its content. Then the current state is queried with the key $\hat{k}_i$ to predict what value would be retrieved: $S_{i-1} \hat{k}_i$. The difference between the actual value $v_i$ and this prediction is the "surprise" — the information that needs to be stored. This surprise is gated by $\beta_i$ (update strength) and written as a rank‑1 update $(\text{surprise}) \times \beta_i \hat{k}_i^\top$ to the state. Finally, the output $o_i$ is produced by querying the updated state with $\hat{q}_i$.

Why this form over cumulative linear attention: The decay gate prevents unbounded state growth — old information naturally fades. The delta‑rule correction makes the state more information‑efficient: if the state already encodes information about a particular key direction, the update writes less in that direction, avoiding redundant accumulation. The combination means the state’s effective memory capacity is used for salient, recent, and surprising information rather than being diluted by stale or redundant content.

Adaptation to video: frame‑wise recurrence. Standard GDN processes one token per recurrent step. For video, this would mean scanning every spatial token of every frame sequentially — $S \times T$ recurrent steps, which is both slow and would mix spatial and temporal information in a single sequential scan. Instead, SANA‑WM operates one latent frame per recurrence step. For a frame $t$ with $S$ spatial tokens, let $\hat{Q}_t, \hat{K}_t, V_t \in \mathbb{R}^{D \times S}$ collect all spatial tokens’ features. The per‑token gates become frame‑level tensors: $\gamma_t \in (0,1]$ is a scalar frame‑level decay (shared across all spatial tokens of the frame), and $\beta_t = \text{diag}(\beta_{t,1}, \ldots, \beta_{t,S})$ is a diagonal matrix of per‑token update gates. The frame‑wise update is:

St=St−1Mt+UtS_t = S_{t-1} M_t + U_t Mt=γt(I−K^tβtK^t⊤)M_t = \gamma_t \left( I - \hat{K}_t \beta_t \hat{K}_t^\top \right) Ut=VtβtK^t⊤U_t = V_t \beta_t \hat{K}_t^\top Ot=StQ^tO_t = S_t \hat{Q}_t

where $S_t, M_t, U_t \in \mathbb{R}^{D \times D}$ are the frame recurrent state, transition matrix, and additive update, respectively, and $O_t \in \mathbb{R}^{D \times S}$ contains the output tokens for frame $t$.

What it computes for a whole frame: The state $S_{t-1}$ is multiplied by the transition matrix $M_t$. This matrix applies the scalar decay $\gamma_t$ and then subtracts a rank‑$S$ correction $\gamma_t \hat{K}_t \beta_t \hat{K}_t^\top$ that selectively removes information along the directions of the current frame’s keys (gated by $\beta_t$). The additive update $U_t$ is an outer‑product sum of the current frame’s values and keys, gated by $\beta_t$. The output $O_t$ queries the updated state with the current frame’s queries. This operation updates a $D \times D$ state and processes all $S$ spatial tokens in parallel within one recurrent step, keeping the temporal recurrence at the frame rate (961 steps for a 60‑second video) rather than the token rate (961 × S steps).

Why frame‑wise over token‑wise: Token‑wise recurrence would mix spatial and temporal context in a single sequential scan, treating a spatial neighbor and a temporal predecessor identically. Frame‑wise recurrence processes all spatial locations jointly in one step, preserving the spatial parallelism of the transformer and letting the model learn distinct spatial (within‑frame) and temporal (across‑frame) interactions.

Algebraic Stabilization for Spatial Token Explosion

A subtle but critical issue arises from the transition matrix $M_t$. For the state $S_t$ to remain stable over long sequences, the transition should be non‑expansive: the spectral norm $\|M_t\|_2$ should be at most 1. If it exceeds 1, repeated multiplication will cause the state to explode. The paper analyzes the key energy in the matrix $A_t = \hat{K}_t \beta_t \hat{K}_t^\top$. Let $\bar{K}_t = [\bar{k}_{t,s}] = \text{ReLU}(\text{RMSNorm}(K_t))$ be the RMS‑normalized and ReLU‑activated key features. The unscaled key energy (trace of $\bar{K}_t \beta_t \bar{K}_t^\top$) is:

tr(At)=∑s=1Sβt,s∥kˉt,s∥22\text{tr}(A_t) = \sum_{s=1}^{S} \beta_{t,s} \|\bar{k}_{t,s}\|_2^2

Since $\bar{K}_t$ has been RMS‑normalized, each $\|\bar{k}_{t,s}\|_2^2 \approx D$ (the head dimension), and $\beta_{t,s} \in [0, 1]$. So $\text{tr}(A_t)$ scales as $O(D \times S)$. Because $A_t$ is positive semidefinite, its maximum eigenvalue $\lambda_{\max}(A_t) \leq \text{tr}(A_t)$. If $\text{tr}(A_t) > 1$, then $I - A_t$ can have eigenvalues < -1, making $M_t = \gamma_t(I - A_t)$ expansive.

The video setting makes this dangerous: $S$ (spatial tokens per frame) is large (hundreds to thousands depending on resolution and compression). The solution is to scale only the keys:

K^t=Kˉt⋅1D⋅S\hat{K}_t = \bar{K}_t \cdot \frac{1}{\sqrt{D \cdot S}}

With this scaling, $\text{tr}(\hat{K}_t \beta_t \hat{K}_t^\top) = \frac{1}{D \cdot S} \text{tr}(A_t) \leq 1$ (since each $\|\bar{k}_{t,s}\|_2^2 \approx D$ and $\beta_{t,s} \leq 1$). Therefore $\|I - \hat{K}_t \beta_t \hat{K}_t^\top\|_2 \leq 1$, and with $\gamma_t \leq 1$, the full transition $\|M_t\|_2 \leq 1$. The $1/\sqrt{D}$ factor matches the standard token‑wise GDN L2 key normalization; the extra $1/\sqrt{S}$ averages over spatial tokens to prevent the trace from scaling with the number of tokens.

What it computes: A scalar normalization applied to every key vector before the state update, dividing by the root of the product of head dimension and spatial token count. This is applied only to the keys, not the queries or values.

Why this form: The $1/\sqrt{D}$ is the standard GDN normalization that keeps the dot‑product between queries and keys at unit scale. The $1/\sqrt{S}$ is novel to the frame‑wise video setting: without it, each frame contributes $S$ rank‑1 updates whose combined energy grows with $S$, and the state would become numerically unstable. An alternative would be to scale by $1/S$ to strictly bound the trace at 1, but $1/\sqrt{S}$ is less aggressive and empirically sufficient (Figure 6: this scaling is the only variant that avoids NaN events during training, while $1/\sqrt{D}$ alone fails at step 16 and no scaling fails at step 1).

Bidirectional and Chunk‑Causal GDN Variants

The same GDN recurrence can be applied in two directions and combined. For bidirectional generation (used in Stage 3 training and offline synthesis), a forward scan (past → future) and a reversed‑time scan (future → past) are computed independently and their outputs summed. This lets each frame attend to all other frames through a combination of forward and backward recurrent states. For chunk‑causal autoregressive inference, the forward scan remains global (seeing all past chunks), but the reversed scan is reset at chunk boundaries — meaning each chunk can see its own future frames but not future chunks. This gives the model local bidirectional context within each chunk without leaking information across chunk boundaries.

Hybrid GDN/Softmax Attention

Even with decay and delta‑rule correction, recurrent attention has an inherent limitation: information from the distant past is blurred through repeated state multiplications. For tasks requiring exact recall of specific past views (e.g., "what color was that building we passed 45 seconds ago?"), the recurrent state may not retain that information with sufficient precision. Softmax attention provides exact, lossless access to any past token through its pairwise attention scores, but scales quadratically in memory and compute.

The hybrid design resolves this by replacing every fourth transformer block with standard softmax attention (FlashAttention‑2). With 20 total blocks, softmax blocks are placed at layers {3, 7, 11, 15, 19}, giving 5 softmax blocks interleaved with 15 GDN blocks. The original QKV and output projection matrices from the pretrained SANA‑Video model are retained; the change is purely in the attention computation mechanism. All GDN and softmax blocks share the same dual‑branch camera conditioning modules.

Why this interleaving pattern: Placing softmax blocks at regular intervals (every 4th block) means that after every few layers of efficient recurrent processing, the model has a "full‑context checkpoint" where every token can attend directly to every other token. This periodic exact attention anchors long‑range spatial consistency — a token representing a distant building can be copied precisely rather than reconstructed from a blurry recurrent memory. The GDN blocks handle the frame‑by‑frame temporal evolution efficiently between these checkpoints. Placing softmax at every 4th block (rather than, say, only the last block) distributes the exact attention throughout the model’s depth, so information from all layers — not just the final one — benefits from precise long‑range access.

Why not all‑softmax: Figure 7b shows the result: an all‑softmax variant with matched resolution, camera conditioning, and FFN settings runs out of H100 memory at 60 seconds because the KV cache grows linearly with sequence length. The hybrid model’s memory stays compact because the GDN blocks maintain a fixed‑size $D \times D$ state regardless of context length.

Dual‑Branch Camera Control (Section 3.3)

With the efficient backbone established, the next challenge is injecting precise 6‑DoF camera control. The paper’s key insight is that a single conditioning rate is insufficient: the VAE compresses 8 raw frames into one latent frame, collapsing distinct camera poses into a single representation. The solution is a coarse branch operating at the latent rate (UCPE attention) and a fine branch operating at the raw‑frame rate (Plücker mixing).

Coarse Branch: Ray‑Local UCPE

UCPE (Unified Camera Positional Encoding) makes the attention operation geometrically aware by transforming queries, keys, and values into a coordinate system aligned with each token’s viewing ray. At test time, the model receives a camera‑to‑world pose $T_t^{\text{c2w}} = [R_t \mid o_t]$ (rotation $R_t$ and camera center $o_t$) and intrinsic matrix $A_t$ for each latent frame $t$.

For a pixel in latent frame $t$ at spatial position $s$, the corresponding world‑space ray is computed by unprojecting the pixel through the intrinsics and transforming by the extrinsics. The result is a camera center $o_t \in \mathbb{R}^3$ and a unit direction vector $d_{t,s} \in \mathbb{R}^3$. A ray‑local orthonormal basis is constructed:

z=norm(dt,s),x=norm(ut×z),y=z×xz = \text{norm}(d_{t,s}), \quad x = \text{norm}(u_t \times z), \quad y = z \times x

where $u_t$ is the camera’s vertical (up) axis. This defines a 3D coordinate frame where $z$ points along the viewing ray, $x$ points to the right in the image plane, and $y$ points up. This frame is packed into a $4 \times 4$ homogeneous transform matrix $D_{t,s}$ that maps world coordinates to this ray‑local frame.

How it integrates with attention: Each attention head in the camera‑conditioning branch splits its channel dimension into two groups: UCPE channels (multiples of 4, for homogeneous 3D coordinates) and standard RoPE channels. For a token $i = (t, s)$ with ray transform $D_i = D_{t,s}$:

Q~ic=(Di⊤⊕RoPEi)Qic\tilde{Q}_i^c = (D_i^\top \oplus \text{RoPE}_i) Q_i^c (K~ic,V~ic)=(Di−1⊕RoPEi)(Kic,Vic)(\tilde{K}_i^c, \tilde{V}_i^c) = (D_i^{-1} \oplus \text{RoPE}_i) (K_i^c, V_i^c) Oic=(Di⊕RoPEi−1)GDNcam(Q~c,K~c,V~c)iO_i^c = (D_i \oplus \text{RoPE}_i^{-1}) \text{GDN}_{\text{cam}}(\tilde{Q}^c, \tilde{K}^c, \tilde{V}^c)_i

where $\oplus$ denotes block‑diagonal composition over the UCPE and RoPE channel groups, and $Q_i^c, K_i^c, V_i^c \in \mathbb{R}^D$ are per‑head camera‑branch query, key, and value vectors.

What it computes step‑by‑step:

  1. Before attention: The query $Q_i^c$ is transformed by $D_i^\top$ (inverse transpose of the ray‑local transform), expressing it in the ray‑local coordinate frame of token $i$ — this is "what token $i$ is looking for, expressed relative to its own viewpoint." The keys and values are transformed by $D_i^{-1}$, expressing them in the world frame — "what each token offers, expressed in a common coordinate system."
  2. During attention: The GDN recurrence operates on these transformed features. Because the queries are in ray‑local frames and the keys/values are in world frames, the attention score between tokens $i$ and $j$ effectively computes: "how relevant is what token $j$ sees (in world coordinates) to what token $i$ is looking for (in its local coordinates)?" This makes the attention equivariant to camera motion: if the camera rotates, the relationship between a query and a key changes appropriately because they are expressed in geometrically meaningful frames.
  3. After attention: The output is transformed back by $D_i$, mapping from world frame to the output token’s ray‑local frame.

The RoPE channels (which do not receive ray‑local transforms) handle conventional spatiotemporal positional encoding, independent of camera geometry.

The camera branch shares the frame‑wise GDN gates with the main branch but uses its own QKV projections. Its output is added to the main attention output through a zero‑initialized projection, meaning at initialization the camera branch contributes nothing, and the model gradually learns to use it.

Why ray‑local over raw pose injection: Simply concatenating the camera extrinsics as a conditioning vector would require the model to learn to interpret raw 6‑DoF parameters and relate them to pixel‑level attention — a complex, non‑linear mapping. The ray‑local transform bakes the geometric relationship directly into the attention computation: the dot product between a ray‑local query and a world‑frame key naturally captures the geometric compatibility between two viewpoints. This is particularly important for long‑horizon consistency because the same scene point observed from different camera positions will have attention scores that reflect the actual 3D geometry.

Fine Branch: Raw‑Frame Plücker Mixing

The UCPE branch operates at the latent rate, but the LTX2 VAE compresses 8 raw frames into one latent frame through its temporal stride. Each of those 8 raw frames has a distinct camera pose, and conditioning only at the latent rate would lose the fine motion within each stride.

The Plücker mixing branch addresses this by injecting geometric information at the raw‑frame rate. For each raw frame $r$ and pixel $p$, using the raw‑frame camera pose $T_r^{\text{c2w}}$ and intrinsics $A_r$, the Plücker raymap is computed as:

ρr,p=(dr,p,  or×dr,p)∈R6\rho_{r,p} = (d_{r,p}, \; o_r \times d_{r,p}) \in \mathbb{R}^6

where $d_{r,p}$ is the unit ray direction and $o_r$ is the camera center. Plücker coordinates encode a 3D line through both its direction $d$ and its moment $o \times d$ (which encodes the line’s position in space). Together, these 6 numbers uniquely identify a viewing ray in world space.

For each latent frame, the 8 raw‑frame raymaps (each $6 \times H \times W$) are stacked into a $48 \times H \times W$ tensor and passed through a zero‑initialized 3D patch embedder that projects them to match the transformer’s hidden dimension. A zero‑initialized per‑block projection then adds this Plücker embedding immediately after each self‑attention output in every transformer block.

Why after self‑attention and not before: Injecting after attention means the Plücker features act as a geometric residual — they correct the attention output based on the precise raw‑frame camera geometry, without interfering with the attention computation itself. If injected before attention, the raw‑frame features would need to compete with the latent‑rate features for the attention mechanism’s limited capacity. The post‑attention injection keeps the geometric correction additive and modular.

Why Plücker coordinates: Alternative raw‑pose representations (e.g., raw extrinsics + intrinsics as a conditioning vector) would require the model to learn the mapping from camera parameters to pixel‑wise ray geometry — exactly the computation that Plücker coordinates provide directly. By pre‑computing the per‑pixel raymaps, the model receives the exact geometric description of each pixel’s viewing ray in world coordinates, eliminating the need to learn this mapping from scratch. The 6D Plücker representation is also compact (compared to, e.g., storing full 3D point clouds) and is the natural parameterization for lines in 3D.

Why both branches are necessary: The ablation in Table 4 shows the effect of each component on the OmniWorld validation split:

  • No camera control: RotErr 16.93°, TransErr 0.2347, CamMC 0.4937
  • Plücker only: RotErr 16.02° — marginal improvement over no control, because raw‑frame geometric information alone cannot provide global trajectory awareness at the attention level
  • UCPE only (latent‑rate ray‑local attention): RotErr 7.73° — large improvement, showing that geometric attention is the primary control mechanism
  • UCPE + Plücker: RotErr 6.21° — further improvement, confirming that the fine branch compensates for intra‑stride motion lost to compression

The two branches are complementary: UCPE provides global trajectory structure in attention space, Plücker provides per‑raw‑frame geometric detail as a post‑attention residual. Neither alone achieves the combined accuracy.

Second‑Stage Refiner (Section 3.4)

The stage‑1 SANA‑WM model is trained under strict efficiency constraints (213K clips, 64 GPUs, 15 days), and its visual quality is expected to trail models trained on orders of magnitude more data. Rather than accepting this quality gap or scaling up training (which would violate the accessibility goal), the paper adds a second‑stage refiner that specifically targets the quality degradation in SANA‑WM outputs. The refiner is not a generic upscaler — it is trained to map SANA‑WM stage‑1 latents to higher‑fidelity versions.

Truncated‑σ Flow Matching

The refiner is trained using a truncated flow‑matching formulation. Let $x_\ell$ be the stage‑1 SANA‑WM latent output, and $x_h$ be the corresponding high‑fidelity target latent (from higher‑quality generation or real video). Rather than learning to map pure noise to $x_h$, the refiner learns to map a degraded version of $x_\ell$ to $x_h$:

  1. Construct a source point by perturbing the stage‑1 latent with large noise: x1=(1−σstart)xℓ+σstartϵ,ϵ∼N(0,I)x_1 = (1 - \sigma_{\text{start}}) x_\ell + \sigma_{\text{start}} \epsilon, \quad \epsilon \sim \mathcal{N}(0, I) where $x_1$ is the noised source, $\sigma_{\text{start}} = 0.909375$ (following the base model schedule), and $\epsilon$ is standard Gaussian noise.

  2. Sample a noise level $\sigma_t$ from a shifted‑logit‑normal distribution truncated to $(0, \sigma_{\text{start}}]$, and compute the interpolation coefficient: α=σt/σstart\alpha = \sigma_t / \sigma_{\text{start}}

  3. The intermediate state is a linear interpolation between the clean target and the noised source: xt=(1−α)xh+αx1x_t = (1 - \alpha) x_h + \alpha x_1 where $\alpha \in (0, 1]$ ensures all training states lie on the line segment connecting $x_1$ (maximally degraded source) and $x_h$ (clean target).

  4. The target velocity (direction from source to target) is: v⋆=x1−xhσstartv^\star = \frac{x_1 - x_h}{\sigma_{\text{start}}}

  5. The model is trained with mean squared error: Lrefiner=Eσt,ϵ∥vθ(xt,σt,c)−v⋆∥22\mathcal{L}_{\text{refiner}} = \mathbb{E}_{\sigma_t, \epsilon} \left\| v_\theta(x_t, \sigma_t, c) - v^\star \right\|_2^2 where $v_\theta$ is the velocity prediction network and $c$ denotes conditioning inputs (text, camera, reference image).

What it computes: The model learns a velocity field along straight paths from noised stage‑1 outputs to high‑fidelity targets. At inference time, starting from a stage‑1 latent $x_\ell$, the noised source $x_1$ is constructed, and the model denoises it toward $x_h$ in a few Euler steps following the learned velocity field. The key difference from standard flow matching is the truncation: noise levels are capped at $\sigma_{\text{start}}$, so the model never sees pure noise — it always starts from a recognizable (if degraded) version of the content.

Why truncated rather than full noise: Full noise‑to‑clean flow matching would require the model to reconstruct all content from scratch, effectively re‑generating the video. Truncated matching focuses the model’s capacity on the specific task of refining — removing artifacts, sharpening details, and correcting structural errors in an already‑plausible video. This is more sample‑efficient because the model does not need to re‑learn content generation; it only needs to learn the correction mapping from SANA‑WM’s output distribution to the target distribution. The $\sigma_{\text{start}} = 0.909375$ is chosen to match the base model’s noise schedule, meaning the refiner operates in the same noise regime as the base model’s final denoising steps.

Why flow matching over diffusion: Flow matching parameterizes the generative process as a continuous normalizing flow (velocity field integration) rather than a discrete diffusion process. The linear interpolation paths are simpler than diffusion trajectories and allow exact likelihood computation. For refinement specifically, the straight‑line paths ensure that the model always interpolates directly between the degraded source and the clean target, without the curved trajectories of standard diffusion that might wander through irrelevant regions of image space.

Reference Conditioning

To maintain identity and appearance consistency with the input first frame, the refiner prepends a clean slice of the target latent (at $\sigma = 0$, i.e., no noise) as reference tokens to the input sequence. These reference tokens act as fixed key‑value anchors through a block‑wise attention mask: they can be attended to by all other tokens, but they do not attend to the noisy sequence. The reference tokens are excluded from the flow‑matching loss, so the model is only trained to refine the video content, not to reproduce the reference.

Why reference tokens as KV anchors: The reference tokens provide the refiner with a pristine, un‑noised view of what the scene should look like from the starting viewpoint. Because they are always at $\sigma = 0$, they serve as a calibration point: the model can compare the noisy/degraded tokens against the clean reference to identify what needs correction. The block‑wise mask (reference → other, but not other → reference) ensures the reference stays unmodified and does not accumulate errors from the noisy sequence.

Implementation: LoRA Adaptation of LTX‑2

The refiner is initialized from the 17B LTX‑2 model (a general‑purpose video diffusion model) and fine‑tuned using rank‑384 LoRA adapters applied to attention (Q/K/V/O) and feed‑forward projections. LoRA is used rather than full fine‑tuning for two reasons: (1) full 17B‑parameter optimization would be computationally expensive and risk catastrophic forgetting of the base model’s video generation capabilities; (2) the refinement task is a specialized mapping that can be captured by low‑rank adaptations to the existing attention and FFN weights.

The training uses paired synthetic data (SANA‑WM stage‑1 outputs paired with higher‑quality versions from longer/more expensive generation) plus real videos that are downsampled and upsampled to create degraded‑clean pairs. The distillation process is notable: directly fine‑tuning the distilled few‑step refiner was unstable, so the LoRA is trained on the multi‑step, non‑distilled LTX‑2 base model, and then zero‑shot merged into the original distilled few‑step model. This transfers the learned long‑video refinement behavior while preserving the distilled inference schedule. At inference, the refiner uses the LTX‑2 stage‑2 distilled sigma schedule [0.909375, 0.725, 0.421875, 0], meaning only three Euler denoising steps are required.

Why this deployment strategy: The refiner adds visual quality but should not dominate the inference budget. By leveraging LTX‑2’s existing few‑step distillation and only adding LoRA adapters, the refiner’s throughput impact is minimized: the full two‑stage pipeline (SANA‑WM stage‑1 + refiner) achieves 22.0 videos/hour on 8 H100s, compared to 24.1 for stage‑1 alone (Table 2). The 17B refiner would be prohibitively expensive if run at full resolution with many denoising steps; the combination of few‑step distillation, LoRA adaptation, and operating in latent space keeps it tractable.

Why a Dedicated Refiner Over Better Stage‑1 Training

The ablation in Table 5 (Appendix A) demonstrates why a general‑purpose refiner fails and why adaptation is necessary. Applying the original LTX‑2.3 refiner directly to 60‑second SANA‑WM latents drastically reduces quality:

  • VBench Overall drops from 80.62 to 71.37 (Simple), 81.89 to 71.16 (Hard)
  • Late‑window imaging quality (IQ50–60) drops from 72.21 to 35.70 (Simple)
  • Rotation error increases from 4.50° to 8.65° (Simple)

The original refiner was trained on short videos and cannot handle the minute‑scale latent distribution. The adapted refiner reverses these degradations: VBench returns to 80.62 (better than stage‑1 alone at 79.29), imaging quality remains stable (ΔIQ drops from 3.79 to 1.17), and rotation error improves from 7.59° (AR stage‑1) to 4.50°. The refiner is therefore not merely improving visual sharpness — it is actively correcting structural and camera‑control errors introduced by the stage‑1 model under limited training.

4. Key Insights and Innovations

Innovation 1: Algebraic Stabilization as a Necessary Condition for Frame-Wise Recurrent Video Generation

The paper's most technically novel contribution is the identification and resolution of a spatial token explosion problem that is specific to frame-wise recurrent attention in video generation — a failure mode that, to our knowledge, has not been previously characterized or addressed in the literature on efficient video transformers.

What makes this distinctive at the idea level: The insight is not that Gated DeltaNet can be applied to video (that is a straightforward adaptation), but rather that the naive frame-wise parallelization of token-wise GDN creates a numerically unstable regime that would cause training to diverge — and that the stabilization requires a scaling factor ($1/\sqrt{D \cdot S}$) whose form depends on the number of spatial tokens per frame, a quantity that never appears in language modeling or standard token-wise GDN. This is a genuine architectural discovery: a parameter-free normalization choice without which the entire hybrid attention design would be non-viable for video.

Prior work comparison: Token-wise GDN (Yang et al., 2024) applies $1/\sqrt{D}$ key normalization as standard practice, inherited from the attention literature where queries and keys are typically normalized to unit L2 norm. This normalization is sufficient for language modeling because each recurrent step processes exactly one token — there is no concept of "spatial explosion" when $S = 1$. The move to frame-wise recurrence, where one step processes $S$ spatial tokens simultaneously through a shared transition matrix $M_t$, introduces a new failure mode that has no analog in token-wise architectures. The paper's Figure 6 demonstrates this empirically: the standard $1/\sqrt{D}$ scaling (and no scaling) both diverge within the first 16 training steps, while $1/\sqrt{D \cdot S}$ trains stably. Prior hybrid architectures (e.g., Qwen3-Next, Kimi Linear) that interleave recurrence with softmax attention operate on language sequences — a single token processed per step — and therefore never encounter this issue. The paper is, to our knowledge, the first to identify that the frame-wise parallelization of recurrent attention requires spatial stabilization that is qualitatively different from standard token-wise normalization.

Significance beyond raw performance: This is not merely a metric improvement — it is a necessary condition for the architecture to exist at all. Without this stabilization, frame-wise GDN training diverges immediately, meaning that no amount of tuning, data, or compute can make the architecture work. The contribution is therefore closer to a theorem about required normalization than to an empirical optimization. It establishes a design principle: any frame-wise recurrent attention mechanism for video must account for the fact that the transition matrix's spectral norm is bounded by the sum of per-spatial-token key energies, and this sum scales with $S$. The $1/\sqrt{D \cdot S}$ scaling generalizes the well-known $1/\sqrt{D}$ attention scaling to this new regime in a principled way. Future work on efficient video transformers that group tokens into parallel recurrent steps will need to address this same issue, making this a reusable architectural insight rather than a SANA-WM-specific hack.

Evidence: Figure 6 (training stability ablation): under identical conditions (81-frame sequences, all-GDN architecture from a shared checkpoint), $1/\sqrt{D \cdot S}$ is the only variant that avoids NaN events. The $1/\sqrt{D}$ baseline fails at step 16; the no-scale baseline fails at step 1. The binary nature of the result (stable vs. NaN) makes it unambiguous: this is not a quality difference but an existence condition.

Innovation 2: The Recurrent State as a Memory Bottleneck Motivating a Specific Hybrid Attention Strategy

The paper reframes the standard hybrid attention design choice — interleaving efficient recurrence with periodic softmax — as a response to a specific, quantified limitation of recurrent memory rather than as a generic "best of both worlds" compromise. This reframing has practical consequences for where to place softmax blocks and why they matter.

What makes this distinctive at the idea level: The paper's framing is subtle but consequential: GDN's recurrent state $S_t \in \mathbb{R}^{D \times D}$ functions as a lossy compression of the entire past, where the decay gate $\gamma_t$ and delta-rule correction determine what is remembered. This compression is extremely efficient (constant memory in context length) but fundamentally lossy — information from distant past frames is blurred through repeated matrix multiplications, and the state's limited rank (bounded by $D$) means it cannot perfectly represent arbitrary past content. Softmax attention, by contrast, provides lossless, exact access to any past token through its pairwise attention scores, but at quadratic cost. The innovation is not using both (many architectures do this) but rather recognizing that softmax blocks serve a specific functional role in a recurrent architecture: they are periodic full-context checkpoints that rescue information that the recurrent state has forgotten or blurred, distributed throughout the model's depth so that all layers — not just the final one — benefit from precise long-range access.

Prior work comparison: Prior hybrid architectures (e.g., Qwen3-Next, Kimi Linear, Kimi K2, cited in Section 2) interleave efficient and exact attention blocks, but their design rationale is typically empirical ("this ratio worked well") rather than principled. The exact placement (every 4th block rather than every 2nd, or only the last block) is usually determined by hyperparameter sweeps rather than a functional argument. By characterizing the recurrent state as a lossy memory and softmax blocks as memory-refresh checkpoints, the paper provides a conceptual framework that predicts certain design choices: (1) softmax blocks should be evenly distributed throughout depth (not clustered at the end), because intermediate layers also suffer from memory degradation; (2) the ratio of softmax to GDN blocks trades off exact recall capacity against efficiency, and the optimal ratio likely depends on the task's long-range dependency requirements. The paper does not fully validate this framework — it tests one configuration (15 GDN + 5 softmax) — but the conceptual reframing is more valuable than the specific ratio because it provides a vocabulary and diagnostic lens for future work.

Significance beyond raw performance: This reframing suggests that the placement of softmax blocks should be guided by analysis of the recurrent state's information content (e.g., measuring the effective rank of $S_t$ over time rather than treating it as a black box). It also implies that different tasks (language modeling vs. video generation vs. world modeling) may require different hybrid ratios because their long-range dependency structures differ — language has syntactic dependencies that span dozens of tokens, while world modeling has visual dependencies that span minutes and require exact recall of scene geometry. The paper's Figure 7b provides indirect evidence: an all-softmax variant exhausts memory at 60 seconds, showing that the hybrid is not just faster but necessary — the recurrent state is the only mechanism that fits in a single GPU's memory. The hybrid design is therefore not a quality optimization but a feasibility constraint for minute-scale video: without GDN recurrence, the model simply cannot fit.

The conceptual advance here is treating the hybrid ratio as a "memory precision vs. memory capacity" tradeoff rather than an "efficiency vs. quality" tradeoff. This frames future work around measuring and improving recurrent state information retention rather than simply sweeping hyperparameters.

Evidence: Table 3 shows the hybrid backbone improves VBench-I2V Total from 0.8390 (cumulative linear attention) to 0.8530 at matched efficiency (5.68 GB vs. 5.40 GB). Figure 7b shows that all-softmax runs out of memory at 60 seconds, while recurrent variants grow compactly. The conceptual claim about memory precision is supported indirectly by the quality improvement from adding softmax blocks to a recurrent-only baseline, though direct measurement of recurrent state information content is not reported.

Innovation 3: Geometry-Aware Attention as a General Mechanism for Camera Control Beyond Conditioning

The paper's dual-branch camera control design represents a fundamental shift in how to inject geometric information into video generation: rather than treating camera parameters as conditioning vectors to be learned, the UCPE branch makes the attention operator itself geometrically equivariant by transforming queries, keys, and values into coordinate systems aligned with each token's viewing ray. This is fundamentally different from prior camera control methods and has implications beyond the specific architecture.

What makes this distinctive at the idea level: Prior camera-controlled video generation methods (CameraCtrl, MotionCtrl, CamCo, cited in Section 2) typically add camera parameters — raw extrinsics, intrinsics, or derived features like Plücker raymaps — as additional conditioning inputs to the model, relying on the model to learn the mapping from these parameters to appropriate pixel motion. The UCPE approach instead builds the geometric relationship directly into the attention computation: the dot product $(D_i^\top Q_i)^\top (D_j^{-1} K_j)$ naturally captures the geometric compatibility between viewpoint $i$ and viewpoint $j$ because both are expressed in geometrically meaningful coordinate systems. The model does not need to learn that "camera rotated 30° right means this pixel should attend to that pixel" — the ray-local transform makes this relationship a structural property of the attention operator, not a learned behavior.

This is a categorical difference: conditioning-based methods give the model geometric hints and trust it to figure out the mapping; UCPE gives the model a geometric substrate that makes the correct mapping the natural computation. The distinction is analogous to the difference between adding 3D coordinates as input features to a neural network versus using an SE(3)-equivariant architecture that guarantees geometric consistency by construction.

Prior work comparison: UCPE was introduced by Zhang et al. (2025) for general camera-controlled video generation, so the core idea is not novel. However, SANA-WM's contribution is (1) demonstrating that UCPE works with recurrent (GDN) attention rather than only with softmax attention, (2) showing that UCPE alone is insufficient at high temporal compression ratios (8:1 in LTX2) because intra-stride motion is lost, and (3) introducing the complementary Plücker mixing branch that recovers this lost motion. The dual-branch design is novel in that it explicitly decomposes camera control into global trajectory structure (handled by UCPE at the latent rate) and fine per-raw-frame motion (handled by Plücker mixing as a post-attention residual). This decomposition is motivated by the specific limitation of aggressive VAE compression, making it a targeted solution rather than a general camera-control module.

Significance beyond raw performance: The key insight is that camera control accuracy at high temporal compression requires geometric information at both the compressed and raw rates. This is a finding about the interaction between VAE design and camera conditioning: the more aggressive the temporal compression, the more important the raw-frame branch becomes. This has implications for efficient video generation broadly — as the field moves toward higher VAE compression ratios for longer videos, camera control schemes that only operate at the latent rate will systematically lose fine motion detail. The dual-branch design can be seen as a compression-aware control strategy that compensates for information loss in the VAE bottleneck through a parallel geometric pathway. Future work on efficient video generation with action conditioning should treat this as a design principle: the conditioning rate must match or exceed the highest-frequency action changes in the data.

The ablation in Table 4 quantifies this decomposition: Plücker alone provides minimal control (RotErr only drops from 16.93° to 16.02°), UCPE alone provides the bulk of the improvement (7.73°), and the combination provides the best result (6.21°). This pattern — that the fine branch has small effect alone but significant effect in combination — confirms that the two branches are complementary: Plücker fixes a specific information gap that UCPE cannot address, rather than providing redundant geometric information.

Evidence: Table 4 (camera control ablation on OmniWorld): UCPE-only achieves RotErr 7.73°, TransErr 0.1350, CamMC 0.2453; UCPE+Plücker achieves 6.21°, 0.1162, 0.2047 — a 20% improvement in rotation error and 17% in camera motion consistency from adding the fine branch. The fact that Plücker-only (16.02°) barely improves over no control (16.93°) while providing substantial benefit in combination is the key evidence for complementarity.

Innovation 4: Native Minute-Scale Training Under Accessible Compute as a Counter-Narrative to Scaling-Only Approaches

Perhaps the paper's most consequential contribution is not a single method but a demonstration and argument: that native minute-scale, 720p, camera-controlled world modeling can be achieved with a 2.6B model trained on ~213K public clips in 15 days on 64 H100 GPUs, yielding competitive or superior results to much larger systems. This is an empirical finding with implications for how the field allocates resources and what it considers "necessary" for long-horizon video generation.

What makes this distinctive at the idea level: The dominant narrative in video generation — reinforced by systems like Sora, MovieGen, and Cosmos — is that long-horizon, high-quality generation requires massive models, enormous datasets, and extended training on huge GPU clusters. SANA-WM challenges this narrative not with a single clever trick but with a co-designed efficiency stack (high-compression VAE + hybrid attention + dual-rate camera control + two-stage refinement) where each component is motivated by a specific resource constraint and validated in isolation before integration. The finding is not "small models are as good as large models" (the paper is careful to note its limitations on hard problems) but rather that efficiency-driven co-design can close the gap with much larger systems on a specific, well-defined task, making world-model research accessible to groups without industrial-scale resources.

Prior work comparison: Prior efficient video generation (SANA-Video, LTX-Video) demonstrated that linear attention and high-compression VAEs can produce high-quality short videos efficiently. Prior world models (HY-WorldPlay, LingBot-World, Matrix-Game 3.0) demonstrated long-horizon camera control but at industrial scale. SANA-WM bridges these lines by showing that the combination of efficiency techniques from the former and capabilities from the latter yields a system that is simultaneously capable (minute-scale, 720p, precise camera control) and accessible (single-GPU inference, consumer-GPU deployment, public data only). This is not an incremental improvement — it is a qualitative change in who can participate in world-model research.

Significance beyond raw performance: The paper's results challenge the implicit assumption that scaling model size, data, and compute is the only viable path to better world models. At fixed total FLOPs, the paper shows that architectural efficiency can substitute for model scale: SANA-WM's 2.6B model achieves action-following accuracy (RotErr 4.50°/8.34° on Simple/Hard, Table 2) that exceeds the 14B+14B LingBot-World (10.47°/18.99°) and the 8B HY-WorldPlay (17.89°/35.46°), while running with 36× higher throughput. This does not mean that scale is irrelevant — the paper's limitations section acknowledges that hard problems remain unsolved and that the model "remains scale-limited" — but it demonstrates that the efficient frontier in world modeling is far from saturated, and that substantial progress can come from architecture design rather than raw compute.

This matters for the research community because it lowers the barrier to entry: a lab with 64 H100s can train SANA-WM from scratch in two weeks, evaluate it on the paper's benchmark, and iterate on architectural improvements. If the only viable path required hundreds or thousands of GPUs and proprietary data, progress would be limited to a handful of industrial labs. The paper's detailed documentation (training hyperparameters in Table 7, data pipeline description in Appendix B, public asset licenses in Table 11) is itself part of the contribution — it makes the system reproducible in a way that most large-scale world-model papers do not.

Fundamental vs. incremental: This is fundamentally a systems contribution with methodological significance. The individual components (LTX2 VAE, GDN, UCPE, two-stage refinement) are not individually novel, and the paper is transparent about this. The novelty is in the integration and the validation: showing that these specific components, combined in this specific way, can achieve competitive long-horizon performance at dramatically reduced cost. The contribution is analogous to the Chinchilla scaling laws (Hoffmann et al., 2022) — not a new technique, but a new understanding of the tradeoffs, validated empirically, that changes how the community allocates resources.

Evidence: Table 2 provides the headline comparison: SANA-WM + refiner achieves 80.62/81.89 VBench Overall on Simple/Hard splits with RotErr 4.50°/8.34°, while running at 22.0 videos/hour on 8 H100s (74.7 GB peak memory). The closest competitor in visual quality, LingBot-World (81.82/81.89), requires 454.1 GB of GPU memory and achieves only 0.6 videos/hour — a 36.7× throughput advantage. The efficiency path in Figure 7a shows the distillation-to-deployment trajectory: from 60-step AR generation on H100 to 4-step distilled AR with NVFP4 quantization on a single RTX 5090 (34 seconds per 60-second clip). This is not merely faster — it enables deployment scenarios (real-time, edge, consumer GPU) that are impossible for the baselines.

5. Experimental Analysis

Evaluation Methodology

  • Dataset and Benchmark. The paper evaluates on a custom-built 60-second world-model benchmark consisting of 80 initial images generated by Nano Banana Pro across four scene categories: game, indoor, outdoor-city, and outdoor-nature (20 each). Each image is paired with two trajectory splits — Simple (smooth one-way planar paths with arcs, S-curves, and backtracking) and Hard (loops, crossings, vertical motion, whip pans, and double loops) — producing 80 scenes × 2 splits = 160 evaluation videos per method. The initial frames are annotated with scene-static first-person prompts describing layout, materials, and lighting while deliberately omitting camera-motion language to prevent text from leaking trajectory supervision. All methods are evaluated using a single generated video per benchmark scene under the same split-specific protocol.

  • Base model(s). The primary base model is PaLM 2-S* (Codey) — not used here (this is an oversight in the reference example; SANA-WM uses its own 2.6B DiT backbone trained from SANA-Video initialization). SANA-WM's trained checkpoints include: the stage-1 2.6B bidirectional model, the stage-1 2.6B chunk-causal AR model, and the optional 17B LTX-2-based refiner (with rank-384 LoRA adapters). The bidirectional model was used for all main table results unless otherwise specified.

  • Metrics. Three categories of metrics are reported. (1) Camera control accuracy: Rotation error (RotErr, in degrees), translation error (TransErr, in meters), and camera motion consistency (CamMC, Frobenius norm of the full pose matrix difference), all lower-is-better, computed by recovering camera poses from generated videos with Pi3X, aligning them to ground-truth trajectories via Umeyama Sim(3) alignment, and averaging per-frame errors. (2) Visual quality: VBench in custom-input mode, reporting eight dimensions (subject consistency SC, background consistency BC, temporal flickering TF, motion smoothness MS, aesthetic quality AQ, imaging quality IQ, dynamic degree DD, overall consistency OC) plus the aggregated VBench Overall score, with dynamic degree weighted by 0.5 in the quality group. (3) Efficiency: Peak GPU memory (GB) and generation throughput (videos/hour) on 8 H100 GPUs. Additional metrics reported in Appendix E.1 include revisit memory (PSNR/SSIM/LPIPS on same-pose pairs where camera position distance < 0.5 m and viewing-angle difference < 20°) and temporal degradation (ΔIQ = imaging quality in first 10-second window minus imaging quality in the last 10-second window, lower-is-better for stability).

  • Baselines. Four recent open-source world models are compared: Infinite-World (Wu et al., 2026; 1.3B parameters, 480p, single-GPU, pose-free hierarchical memory for 1000-frame horizons), LingBot-World (Team et al., 2026; 14B+14B parameters, 480p, 8 GPUs), HY-WorldPlay (Sun et al., 2025; 8B parameters, 480p, 8 GPUs, long-term geometric consistency via explicit memory), and Matrix-Game 3.0 (Wang et al., 2026; 5B parameters, 720p, 8 GPUs, real-time streaming interactive world model). Note that SANA-WM is the only method operating at 720p on a single GPU; LingBot-World supports 720p in principle but minute-long 720p inference was "unaffordable under our 8-H100 evaluation budget" (Section 5.3), so it is evaluated at 480p in the main table.

  • Generation budget / compute accounting. Efficiency is measured by GPU memory (peak GB on a single H100 for SANA-WM, on 8 H100s for baselines) and throughput (60-second videos generated per hour on 8 H100s). The generation budget is not framed as a FLOPs or token count but rather as the end-to-end inference cost for producing one 60-second video under each model's native protocol. All methods use their multi-step, undistilled AR inference setting for the main comparison. For SANA-WM variants, the chunk-causal AR model runs at 60 denoising steps (stage-1) plus three Euler refiner steps (stage-2); the distilled path in Section 5.4 uses 4 denoising steps with NVFP4 quantization.

  • Cross-validation / statistical protocol. No cross-validation is reported. All methods are evaluated once per benchmark scene per split (80 scenes × 2 splits = 160 total evaluations per method). The benchmark construction (Appendix D.1) includes reproducibility measures — scene metadata, prompts, calibrated intrinsics, metric camera trajectories, collision status, and model-specific action inputs — but the evaluation itself is a single pass without uncertainty quantification (no confidence intervals, error bars, or multiple seeds reported in the main tables).

Main Quantitative Results

Camera Control Accuracy

Table 2 presents the primary comparison of camera-following accuracy across all methods on both Simple and Hard trajectory splits.

On the Simple split: SANA-WM + refiner achieves the best results among all methods — RotErr 4.50°, TransErr 1.39, CamMC 1.41. This outperforms LingBot-World (RotErr 10.47°, TransErr 2.01, CamMC 2.05 — the strongest 480p baseline) by more than 2× on rotation error, Matrix-Game 3.0 (RotErr 12.96°, TransErr 1.83, CamMC 1.92 — the only other 720p method) by nearly 3×, and the stage-1 SANA-WM AR model alone (RotErr 7.59°, TransErr 1.59, CamMC 1.63) by ~40%. The refiner provides a substantial camera-control improvement beyond its visual-quality role: rotation error drops from 7.59° (stage-1 AR) to 4.50° (with refiner), suggesting the refiner corrects geometric drift as well as visual artifacts.

On the Hard split: The pattern holds but with larger absolute errors for all methods — the Hard trajectories include vertical motion, pitch changes, and loop closures that stress camera control. SANA-WM + refiner again leads: RotErr 8.34°, TransErr 1.39, CamMC 1.44. The gap to LingBot-World widens (RotErr 18.99° vs. 8.34°), and HY-WorldPlay degrades substantially (RotErr 35.46° on Hard vs. 17.89° on Simple), indicating that HY-WorldPlay's geometric consistency mechanisms do not handle aggressive trajectories well. Infinite-World shows the weakest camera control on Hard (RotErr 41.31°), consistent with its pose-free design that lacks explicit metric camera conditioning.

Key pattern: SANA-WM's camera control advantage is largest relative to baselines on the Hard split, suggesting the dual-branch design is particularly effective at maintaining trajectory adherence under aggressive motion where simpler conditioning schemes fail. The refiner's contribution to pose accuracy (not just visual quality) indicates that the stage-1 model produces videos with recoverable but slightly drifted geometry, and the refiner tightens this alignment.

Visual Quality

VBench scores in Table 2 provide a multi-dimensional visual quality comparison.

Aggregate VBench Overall: On the Simple split, SANA-WM + refiner achieves 80.62, nearly matching LingBot-World's 81.82 (the highest among baselines) while operating at 720p on a single GPU. Matrix-Game 3.0 reaches 78.53 at 720p on 8 GPUs. On the Hard split, SANA-WM + refiner and LingBot-World tie at 81.89 — an interesting result where the harder trajectories do not degrade SANA-WM's visual quality (VBench actually increases from 80.62 to 81.89 from Simple to Hard, possibly because more dynamic motion masks static artifacts or because VBench's dimensions reward motion smoothness on challenging trajectories). HY-WorldPlay shows the largest quality degradation from Simple to Hard (68.82 → 70.46), consistent with its severe temporal degradation on Hard trajectories (ΔIQ 25.88, Table 8).

Per-dimension patterns: Examining the eight VBench dimensions reveals where methods differ. SANA-WM + refiner achieves the highest temporal flickering scores (TF 96.18/95.54 on Simple/Hard) and competitive subject/background consistency (SC 88.62/87.26, BC 93.21/92.55). However, it scores lower on dynamic degree (DD 61.25/91.25 on Simple/Hard) and overall consistency (OC 11.12/11.34) compared to Infinite-World (DD 88.75/98.75) and Matrix-Game 3.0 (DD 97.50/98.75). The dynamic degree metric measures the magnitude of motion in the generated video, and lower DD here likely reflects that VBench's DD scoring penalizes videos that do not match the motion distribution of its training data rather than indicating insufficient motion — SANA-WM's trajectories are fixed by the benchmark and the model follows them, but VBench's DD reference distribution may not align with the specific camera paths used. The low OC scores across all methods (11.12–13.65 range) suggest this dimension is a known weak point for custom-input VBench evaluation rather than a SANA-WM-specific failure.

Visual quality without the refiner: Stage-1 SANA-WM alone achieves VBench Overall 79.29/79.60 on Simple/Hard — competitive with Infinite-World (79.18/79.51) and Matrix-Game 3.0 (78.53/78.79) despite being a 2.6B single-GPU model. The refiner adds approximately 1.3–2.3 VBench Overall points, with the largest gains in aesthetic quality (AQ: 55.70 → 58.05 on Simple) and imaging quality (IQ: 69.69 → 72.12 on Simple).

Inference Efficiency

Table 2 reports memory and throughput for all methods on 8 H100 GPUs.

Memory: SANA-WM stage-1 uses 51.1 GB (single GPU), and with the refiner, 74.7 GB (still within the 80 GB H100 budget on a single GPU). The next most efficient baseline is Matrix-Game 3.0 at 106.2 GB (8 GPUs), followed by HY-WorldPlay at 215.5 GB (8 GPUs), and LingBot-World at 454.1 GB (8 GPUs). Infinite-World uses 53.5 GB, close to SANA-WM's memory, but operates at 480p vs. SANA-WM's 720p and shows substantially weaker camera control.

Throughput: SANA-WM stage-1 produces 24.1 videos/hour on 8 H100s, compared to Infinite-World's 5.9 (4.1× faster), Matrix-Game 3.0's 3.1 (7.8× faster), HY-WorldPlay's 1.1 (21.9× faster), and LingBot-World's 0.6 (40.2× faster). With the refiner, throughput drops modestly to 22.0 videos/hour (36.7× faster than LingBot-World). The paper's headline "36× higher throughput" compares SANA-WM + refiner (22.0) to LingBot-World (0.6), which is the strongest baseline in visual quality. However, the comparison is not strictly like-for-like: LingBot-World runs at 480p in the evaluation, and its 720p throughput would be even lower (the paper states 720p inference was "unaffordable under our 8-H100 evaluation budget" for LingBot-World).

Deployment efficiency path (Section 5.4, Figure 7a): The paper traces the full efficiency trajectory from research to deployment. The base AR model (60 denoising steps, H100) → 4-step distillation (self-forcing) → attention-sink deployment (first latent frame as persistent KV-cache anchor with local temporal windows on softmax layers) → NVFP4 quantization on RTX 5090. The final distilled variant generates a 60-second 720p clip in 34 seconds on a single RTX 5090. The bar chart in Figure 7a breaks down latency between VAE encoding/decoding and DiT denoising, showing that the DiT dominates at 60 steps but becomes manageable at 4 steps.

Efficiency scaling with context length (Figure 7b): This is a critical scaling plot that compares single-step H100 latency and memory for recurrent (GDN/linear) variants versus an all-softmax variant at matched resolution, camera conditioning, and FFN settings. The recurrent variants maintain compact, nearly constant memory and latency as context length grows from 5s to 60s. The all-softmax variant grows its KV cache linearly and runs out of memory at 60s. This demonstrates that the hybrid design is not merely faster — it is necessary for minute-scale generation on a single GPU, because pure softmax attention simply cannot fit.

Revisit Memory and Temporal Stability

Table 8 (Appendix E.1) reports metrics that test long-horizon scene persistence.

Revisit memory: SANA-WM + refiner achieves PSNR 14.46/14.80 dB on Simple/Hard, ranking second on Simple (after LingBot-World's 14.59) and first on Hard (above LingBot-World's 14.08). The refiner consistently improves PSNR over stage-1 alone (14.16 → 14.46 on Simple, 14.10 → 14.80 on Hard), though LPIPS sometimes degrades slightly (0.458 → 0.479 on Simple), suggesting the refiner improves structural alignment at the cost of slightly different texture statistics measured by the perceptual metric. HY-WorldPlay performs worst on revisit memory (PSNR 12.83/13.72), consistent with its geometric consistency being insufficient for exact loop closures.

The paper notes that revisit pairs are evaluated by timestamp alignment (generated frame indices mapped to the 16 fps reference rate). This is important because different baselines use different native frame rates, and misaligned timestamps would make the PSNR/SSIM/LPIPS comparison meaningless. The protocol accommodates this by remapping.

Temporal degradation (ΔIQ): The refiner dramatically reduces long-horizon visual drift. Stage-1 SANA-WM shows ΔIQ of 3.79/3.09 on Simple/Hard, meaning imaging quality drops by 3.79 and 3.09 VBench IQ points between the first and last 10-second windows of the minute-long video. With the refiner, ΔIQ drops to 1.17/0.31 — the Hard split actually shows better stability after refinement (0.31 vs. 1.17), an interesting result that may reflect the refiner's training data distribution or the nature of the trajectories. For comparison, HY-WorldPlay shows severe degradation (ΔIQ 23.59/25.88), meaning its visual quality collapses in the latter portion of long videos. LingBot-World achieves the best stability (0.04/0.58), consistent with its explicit memory mechanisms.

Why this matters: ΔIQ directly measures a failure mode that is invisible in aggregate VBench scores: a model could have good average quality while degrading severely over time, which would make it useless for long-horizon simulation. HY-WorldPlay is the clearest example — its VBench Overall (68.82/70.46) is not dramatically worse than other methods, but its near-total collapse in late-window quality (IQ50–60 drops to 46.50/44.33 on Simple/Hard, compared to IQ0–10 of 70.08/70.21) makes it unreliable for minute-scale rollouts. The paper's ΔIQ metric and the refiner's role in reducing it demonstrate that the two-stage pipeline addresses a real temporal consistency problem, not just a cosmetic quality issue.

Qualitative Results

Figure 5 provides qualitative comparisons of four Hard-Trajectory 60-second videos across methods. The paper highlights that SANA-WM "preserves scene identity and viewpoint-consistent structure under hard actions, whereas baselines often blur, change layout, or collapse." Figure 11 (Appendix E.3) provides three additional Hard-Trajectory examples with similar findings. Figure 8 (Appendix A) isolates the refiner's effect: side-by-side frames from 10s to 50s show that the refiner improves visual fidelity (sharper details, fewer structural artifacts) and temporal consistency, with red boxes highlighting local regions where the improvement is visible. Figure 12 (Appendix E.4) provides a 3D reconstruction visualization: Pi3X recovers coherent 3D structure and camera paths from SANA-WM-generated videos, indicating that the generated videos contain consistent 3D cues over the full minute — a qualitative probe that pixel-level metrics alone might miss.

Ablation Studies and Robustness Checks

  • Progressive-training ablation (Table 3, Appendix E.2 Table 10): Evaluated on VBench-I2V at a 5s horizon with identical data and inference settings. The LTX2 VAE swap is quality-neutral (+0.0012 Total) while reducing peak memory from 8.9 GB to 5.4 GB and latency 3.4× (from 1266.6 ms to 371.7 ms per step). The hybrid 15-GDN/5-softmax backbone further raises Total from 0.8390 to 0.8530, with gains concentrated in subject/background consistency and I2V-specific dimensions (camera_motion 0.3942 → 0.4343, i2v_subject 0.9309 → 0.9450). Memory increases modestly from 5.4 GB to 5.68 GB. The decomposition in Table 10 shows that the hybrid backbone improves long-range consistency dimensions (subject consistency 0.8346 → 0.8564, background consistency 0.9048 → 0.9114), consistent with the claim that periodic softmax blocks anchor long-term spatial consistency.

  • GDN key scaling stability (Figure 6): Under identical conditions (81-frame sequences, all-GDN architecture from a shared LTX2-VAE cumulative-linear checkpoint), three scaling variants are compared: 1/√(D·S) (the paper's proposed scaling), 1/√D (standard token-wise GDN L2 key normalization), and no scaling. Only 1/√(D·S) converges stably. 1/√D triggers NaN events at step 16; no scaling fails immediately at step 1. This is a binary result — the architecture is either stable or immediately divergent — making the claim unambiguous: the spatial token count S must appear in the key normalization for frame-wise GDN to be trainable. The finding is non-obvious because S does not appear in any prior GDN formulation, and the paper is the first to identify that the frame-wise parallelization introduces this dependence.

  • Camera-conditioning ablation (Table 4): Evaluated on a held-out OmniWorld validation split with 5s clips after 10K fine-tuning steps. Five conditions are compared: no control, Plücker only (raw-frame raymaps injected as input), PRoPE (Cameras as Relative Positional Encoding, an attention-level camera encoding), UCPE only (ray-local attention at latent rate), and UCPE + Plücker (the full dual-branch design). The key findings: (1) Plücker-only provides minimal improvement over no control (RotErr 16.93° → 16.02°, FVD 348.93 → 339.45), indicating that raw geometric information without attention-level integration is insufficient; (2) PRoPE and UCPE both provide large improvements (RotErr 6.29° and 7.73°, respectively), showing that attention-level camera encoding is the dominant mechanism; (3) UCPE + Plücker yields the best results on TransErr (0.1162 vs. 0.1350 for UCPE alone) and CamMC (0.2047 vs. 0.2453), while RotErr is comparable to PRoPE (6.21° vs. 6.29°). The FVD for UCPE + Plücker (320.80) is slightly worse than UCPE alone (314.88), suggesting a minor quality tradeoff for the improved control accuracy — the paper does not discuss this, but it is worth noting.

  • Refiner ablation (Table 5, Appendix A): Evaluated on the full 60-second benchmark using identical SANA-WM stage-1 latents, comparing the proposed adapted long-video refiner vs. the original short-video LTX-2.3 refiner applied directly. The original refiner is catastrophic at minute scale: VBench Overall drops from 80.62 to 71.37 (Simple) and 81.89 to 71.16 (Hard); late-window imaging quality collapses (IQ50–60 drops from 72.21 to 35.70 on Simple); rotation error worsens (4.50° → 8.65° on Simple). The adapted refiner reverses all of these: VBench returns to 80.62/81.89, IQ50–60 recovers to 72.21/73.03, ΔIQ improves from 3.79 to 1.17 (stage-1 to refiner), and rotation error improves. This ablation demonstrates that the refiner is not a generic quality boost — it must be specifically adapted to the distribution of minute-scale SANA-WM latents, and a general-purpose short-video refiner actively damages both quality and control.

  • Bidirectional vs. autoregressive generation (Table 9, Appendix E): Compares the bidirectional (full-context, non-causal) and autoregressive (chunk-causal) SANA-WM stage-1 variants on the full benchmark. The bidirectional model achieves substantially better camera control (RotErr 3.11°/3.17° on Simple/Hard vs. 7.59°/10.02° for AR) at the cost of some visual quality (VBench Overall 79.39/80.18 vs. 79.29/79.60) and temporal stability (ΔIQ 2.25/2.13 vs. 3.79/3.09). This quantifies the performance gap between offline (bidirectional) and streaming (AR) generation — the AR model loses camera accuracy because it cannot attend to future frames for trajectory planning. The throughput difference (29.5 vs. 24.1 videos/hour for bidirectional vs. AR) is modest. Revisit memory is comparable (PSNR 13.74/13.78 bidirectional vs. 14.16/14.10 AR). The main table uses AR for all methods to ensure a fair comparison under the same generation paradigm.

  • Efficiency scaling with context length (Figure 7b): Beyond the OOM-vs-compact result, this ablation shows the quantitative scaling behavior: at 5s, all variants have similar memory and latency; at 30s, the recurrent variant's memory is ~3× lower than all-softmax; at 60s, the recurrent variant fits in ~50 GB while all-softmax exceeds 80 GB. The linear/recurrent variant curves are nearly flat, demonstrating that the constant-memory property of GDN recurrence translates to practical single-GPU deployment across the full minute scale. This is an existence proof: without GDN, minute-scale 720p generation on a single H100 is impossible.

  • Distillation and deployment path (Figure 7a): The 4-step distilled AR model with NVFP4 quantization on RTX 5090 achieves 34s per 60s clip. The breakdown is instructive: VAE encode/decode dominates at low step counts (the VAE is not compressed by distillation), while DiT denoising dominates at high step counts. The inference time is reported as total wall-clock time including VAE encoding, DiT denoising, and VAE decoding, making it an end-to-end deployment measurement rather than an idealized DiT-only latency.

Critical Assessment

The experiments provide strong evidence for several of the paper's central claims, but the support is uneven and several important questions remain unaddressed.

Claim 1: SANA-WM achieves stronger action-following accuracy than prior open-source baselines while delivering up to 36× higher throughput.

The evidence for this claim is solid and multi-faceted. Table 2 shows SANA-WM + refiner achieving the lowest rotation and translation errors on both Simple and Hard splits, with the advantage largest against baselines that show severe degradation on Hard trajectories (HY-WorldPlay RotErr 35.46°, Infinite-World 41.31°). The throughput comparison (22.0 vs. 0.6 videos/hour vs. LingBot-World) is dramatic. However, three qualifications are necessary:

First, the comparison is not fully like-for-like on visual quality: LingBot-World achieves marginally higher VBench Overall on Simple (81.82 vs. 80.62) and ties on Hard (81.89 vs. 81.89), and it operates at 480p in the evaluation. The claim that SANA-WM achieves "comparable visual quality" is fair, but the claim of "stronger action-following" must be weighed against the resolution mismatch — LingBot-World at 720p might achieve different camera control accuracy (the paper acknowledges 720p LingBot-World inference was unaffordable, but this means the comparison at maximum quality settings was not performed).

Second, the 36× throughput figure compares SANA-WM's most optimized configuration (22.0 videos/hour with refiner) against the slowest baseline (LingBot-World at 0.6). Against Infinite-World (5.9 videos/hour), the advantage is 3.7× — still substantial but less dramatic. The headline number is valid but should be understood as the upper bound of the efficiency gap, not the typical advantage.

Third, the camera control metrics use Pi3X for pose recovery from generated videos. This introduces a potential confound: Pi3X's accuracy on generated videos (which may contain artifacts, blur, or geometric inconsistencies that differ from real video) affects the measured errors. If Pi3X is less accurate on one model's outputs than another's, the comparison would be biased. The paper does not validate Pi3X on generated video of known geometry, which would be necessary to rule out this confound.

Claim 2: Minute-scale 720p world modeling is achievable under accessible compute budgets (64 H100s, 15 days, single-GPU inference).

This claim is well-supported by the training details in Table 7 and the inference efficiency in Table 2 and Figure 7. The total training compute (~23,040 H100-hours) is indeed accessible to academic labs and smaller companies. The single-GPU inference results (51.1 GB for stage-1, 74.7 GB with refiner) are demonstrated on real hardware. The distilled deployment to consumer GPU (RTX 5090, 34s per clip) is demonstrated in Figure 7a.

However, the claim elides the cost of the refiner: the 17B LTX-2 model was pretrained by a different team at a scale not reported here, and the LoRA adaptation uses that pretrained model. A group reproducing SANA-WM from scratch could train the 2.6B stage-1 model but would need access to the LTX-2 checkpoint for the refiner. The paper is transparent about this (the refiner is "initialized from the 17B LTX-2 model"), but the "accessible compute" claim applies primarily to the stage-1 model, not the full two-stage pipeline.

Additionally, the data pipeline (VIPE + Pi3X + MoGe-2 pose annotation on ~213K clips) requires running these models on the full training corpus — a computational cost not accounted for in the "15 days on 64 H100s" figure, which covers only DiT training. The VAE adaptation (50K steps, ~3.5 days) is included, but the pose annotation cost is externalized. This is reasonable for a paper focused on model architecture, but it means the total compute to go from raw public videos to trained model is higher than the reported training time.

Claim 3: The hybrid GDN/softmax architecture is necessary for minute-scale single-GPU generation and the GDN key scaling stabilization is required for training stability.

The evidence for the necessity claim is strong. Figure 7b directly shows all-softmax running out of memory at 60s at matched settings — this is not a relative comparison but a binary feasibility result. Figure 6 demonstrates that the 1/√(D·S) key scaling is required for training stability — the other variants diverge within 16 steps. These are clean, unambiguous ablations.

However, the architecture was tested at only one hybrid ratio (15 GDN + 5 softmax). The paper does not ablate the number or placement of softmax blocks, making it unclear whether 5 is optimal, whether the interleaving pattern matters (every 4th block vs. clustered), or whether different ratios might be better for different sequence lengths. The conceptual framing (softmax blocks as periodic memory-refresh checkpoints) is interesting but not validated by measurements of recurrent state information content — the paper does not report effective rank of S_t, mutual information between recurrent state and past frames, or any other quantitative metric of memory quality.

Additionally, the GDN key scaling is validated on 81-frame sequences (Figure 6), but the main model trains on 961-frame sequences. The paper implies the scaling generalizes, but does not explicitly test whether longer sequences introduce additional numerical challenges that the 1/√(D·S) scaling might not fully address. The training stability on 961-frame sequences is demonstrated indirectly (training completes), but the scaling analysis is only shown for the shorter context.

Claim 4: The dual-branch camera control (UCPE + Plücker) is superior to single-rate conditioning.

The ablation in Table 4 supports this claim for the 5s OmniWorld validation split. UCPE + Plücker achieves the lowest TransErr and CamMC, and competitive RotErr. The complementarity argument (Plücker alone does little, UCPE alone is good, combination is best) is supported by the pattern of results.

However, the ablation is limited in two ways. First, it uses only 5s clips after only 10K fine-tuning steps — the full model trains on 60s clips for 31K steps. The relative importance of the Plücker branch might increase at longer durations because intra-stride motion errors accumulate over more frames. The 5s ablation may underestimate the Plücker contribution for the full model. Second, the ablation uses the OmniWorld validation split (a synthetic dataset with ground-truth depth), not the main benchmark. The relative performance of conditioning strategies might differ on real video, where camera poses are noisier and geometric structure is less perfect. The paper does not report a per-branch ablation on the main benchmark.

Claim 5: The dedicated long-video refiner is necessary — a general-purpose short-video refiner degrades quality.

Table 5 provides compelling evidence: the original LTX-2.3 refiner is catastrophic on minute-scale SANA-WM latents. This is a clean ablation with identical stage-1 inputs, isolating only the refiner variant. The large effect sizes (VBench Overall drop of 9.3/10.7 points on Simple/Hard, IQ50–60 drop of 36.5/39.3 points) make the conclusion unambiguous.

The mechanism is not fully explained: why does a short-video refiner fail so dramatically on long latents? The paper attributes it to distribution shift, but does not characterize the shift (e.g., are the latents statistically different in mean/variance, or does the problem stem from the refiner's inability to handle the temporal extent?). This is a missing diagnostic that would strengthen the claim and guide future work.

What is missing:

  1. Multiple random seeds or error bars: All main table results are single-point estimates without any measure of variance. For the Hard split with 80 scenes, per-scene variance could be substantial, especially on challenging trajectories. The paper would be stronger with confidence intervals or at minimum reporting that results are stable across runs.

  2. Ablation of softmax block count and placement: The hybrid ratio (15/5) is stated as a design choice but never ablated. This is a significant gap given that the hybrid attention is a core architectural contribution. How does performance change with 1, 3, 5, or 10 softmax blocks? Does placement matter (early vs. late vs. uniform)?

  3. Ablation of refiner on the main benchmark by difficulty: The refiner's contribution is aggregated across all 80 scenes. Does it help more on Simple or Hard trajectories? On indoor vs. outdoor scenes? On scenes with more or less texture? This breakdown would help users decide when the refiner is worth its computational cost.

  4. Per-category results: The benchmark has four scene categories (game, indoor, outdoor-city, outdoor-nature) but results are not broken down by category. This matters because world models may perform differently on synthetic-looking game scenes vs. photorealistic outdoor scenes, and the aggregate metrics could hide large category-specific failures.

  5. Training data ablation: The model trains on ~213K clips from seven sources. Which sources contribute most? Does removing real video (keeping only synthetic DL3DV and Sekai) degrade real-world performance? Does removing synthetic data hurt camera control accuracy (since synthetic data has perfect ground-truth poses)? A data ablation would clarify which parts of the pipeline are essential.

  6. Comparison at matched resolution: All baselines except Matrix-Game 3.0 and SANA-WM operate at 480p. A comparison where SANA-WM is downscaled to 480p (or baselines upscaled to 720p, though this proved infeasible for some) would isolate the effect of resolution from other architectural differences.

  7. Human evaluation: VBench and camera pose recovery are automated metrics. For a system whose output is meant to be visually plausible to humans, a human preference study (even small-scale) would validate that the automated metrics track human judgment, particularly for the refiner's visual quality improvements.

  8. Longer rollouts: The paper generatively targets exactly 60 seconds. What happens at 90s or 120s? Does the recurrent state eventually degrade, or does the chunk-causal AR mechanism maintain quality indefinitely? The efficiency scaling plot (Figure 7b) goes to 60s but not beyond — extending this to the limits of single-GPU memory would characterize the architecture's scaling ceiling.

Overall assessment: The experiments convincingly demonstrate that SANA-WM achieves a specific and valuable point on the efficiency-capability Pareto frontier: competitive camera control and visual quality at dramatically lower compute than prior work. The architectural ablations are well-designed and support the paper's technical claims, though several important dimensions (hybrid ratio, data composition, per-category performance, human evaluation) remain unexplored. The main limitation is that the evaluation operates as a point estimate on a single benchmark construction without variance characterization, making it difficult to assess the reliability of the precise numerical comparisons. The paper's contribution is primarily a systems demonstration — that careful co-design of VAE compression, attention mechanism, camera conditioning, and refinement can make minute-scale world modeling accessible — and the experiments succeed in making that case.

6. Limitations and Trade-offs

The Difficulty Estimation Bottleneck — Practical Deployment Requires Solving It

The assumption or constraint. The entire compute-optimal test-time scaling framework depends on estimating prompt difficulty before allocating the inference budget, but the paper's method for doing so is extraordinarily expensive. Section 3.2 describes generating 2048 samples per question and scoring them to bin questions into five difficulty quintiles. The authors explicitly acknowledge this in Section 3.2:

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

The consequence. The headline 4× efficiency gains over best-of-N are computed after difficulty is known, without amortizing the cost of learning it. Generating and scoring 2048 samples per question consumes more compute than the largest test-time budgets studied (256-512 generations). In a realistic deployment, the total cost would be difficulty estimation + strategy execution, where the former could dominate the latter. A user with 1000 questions to evaluate would spend 1000 × 2048 = 2,048,000 generations just on difficulty estimation before any strategic allocation begins. The reported gains should therefore be understood as an upper bound on achievable efficiency, not a realized deployment gain.

What evidence exists in the paper. Section 3.2 explicitly describes the cost (2048 samples per question), and Figures 4 and 8 plot compute-optimal scaling curves that start from zero budget on the x-axis — meaning the difficulty estimation cost is not added to the total. The paper does not report total inference cost including estimation.

Mitigation status. The authors acknowledge this limitation and "frame it as an exploration-exploitation tradeoff — compute spent assessing difficulty versus compute spent solving the problem — flagging it as a key avenue for future work" (Section 3.2). No lightweight difficulty estimator is developed or evaluated. Section 8 suggests future work on training models to predict difficulty directly from question text. Until such a model exists, the method remains impractical for deployment at scale despite its demonstrated efficiency in controlled evaluation.

No Evidence Beyond MATH and PaLM 2-S* — Generalisation Is Unconfirmed

The assumption or constraint. All experiments use a single benchmark (MATH, 500 test questions) and a single model family (PaLM 2-S*). Section 4 states the authors "believe this model is representative of the capabilities of many contemporary LLMs," but this claim is unverified.

The consequence. Multiple aspects of the findings could be model-specific or benchmark-specific. The PRM's quality and over-optimization behavior depend on PaLM 2-S*'s output distribution — a model with different calibration or error patterns might exhibit different difficulty-dependent scaling curves. The revision model's ability to learn from incorrect in-context examples depends on the base model's in-context learning capabilities, which vary substantially across model families. The MATH benchmark consists exclusively of competition-level math problems requiring symbolic reasoning — it is unknown whether the difficulty-dependent patterns (beam search hurting easy problems, revisions helping easy problems) generalize to other reasoning domains (code generation, logical reasoning, scientific QA) or to tasks requiring factual knowledge rather than inference. A practitioner working with a different model family (e.g., Llama, GPT) or a different task domain cannot assume the quantitative scaling relationships will transfer.

What evidence exists in the paper. No cross-model or cross-benchmark results are reported. The paper does not evaluate on any benchmark other than MATH, and does not experiment with any model other than PaLM 2-S* (and the ~14× larger comparison model, also from the same family). All difficulty bins, optimal strategies, and scaling curves are conditioned on this specific model-benchmark pair.

Mitigation status. The authors acknowledge the single-model limitation in Section 4 but treat it as acceptable scope rather than a gap to be filled. No cross-model replication is attempted. A practitioner seeking to apply this framework to their own model and task would need to re-derive the optimal strategies from scratch, including re-training PRMs on their model's output distribution (the paper shows in Appendix J, Figure 15a, that even transferring a PRM from base model outputs to revision model outputs causes performance degradation due to distribution shift — cross-model transfer would likely be worse).

Hard Problems Remain Fundamentally Unsolved — Test-Time Compute Cannot Substitute for Missing Capability

The assumption or constraint. The paper demonstrates that test-time compute can amplify existing capability but cannot create it. Section 7 makes this explicit:

"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."

The consequence. For problems where the base model's pass@1 is near zero, no amount of search, revision, or compute-optimal allocation helps. In the FLOPs-matched comparison (Section 7, Figure 9), difficulty bin 5 (hardest) shows near-zero accuracy regardless of budget or method. This means SANA-WM offers no path forward for genuinely novel or out-of-distribution reasoning that exceeds the base model's training distribution. A practitioner deploying this system cannot expect it to solve problems the base model cannot already solve at least occasionally — the system can only improve the probability of finding a correct answer the model already knows how to produce, not teach the model new capabilities. This is a hard boundary on the applicability of test-time compute scaling.

What evidence exists in the paper. Figure 3 (right): bin 5 accuracy hovers at 1-3% for all methods and all budgets. Figure 7 (right): bin 5 shows roughly 2-3% accuracy irrespective of sequential-to-parallel ratio. Figure 9: the bin 5 scaling line is essentially flat near 0-5% across all compute budgets. Table 2: SANA-WM + refiner achieves its lowest performance on Hard splits (RotErr 8.34° vs. 4.50° on Simple), though this is still better than baselines. The FLOPs-matched comparison (Section 7) shows that for hard problems, pretraining the larger model almost always wins regardless of R value.

Mitigation status. The paper is candid about this limitation. Section 7 states that "test-time compute amplifies existing capability but does not create it from nothing" and that for hard problems, "pretraining remains the only viable path." No mitigation is proposed for the fundamental capability gap — the limitation is treated as inherent to the test-time compute paradigm. The compute-optimal policy at least correctly identifies these problems and routes them away from wasteful compute expenditure (best-of-N baseline is used for bin 5), but accuracy remains near zero.

The 14× Larger Model Baseline Is Artificially Weakened — Training-Inference Tradeoff Magnitudes May Be Overstated

The assumption or constraint. The FLOPs-matched comparison in Section 7 scales model parameters while holding training data fixed, following the LLaMA paradigm rather than Chinchilla-optimal training where both data and parameters are scaled equally. The authors acknowledge this:

"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."

Additionally, the larger model uses only greedy decoding — no majority voting, no best-of-N, no test-time compute augmentation of any kind.

The consequence. A Chinchilla-optimal model trained with 14× more total FLOPs (scaling both parameters and data) would likely outperform a parameter-only-scaled model, making the pretraining baseline weaker than it needs to be. The reported advantages of test-time compute over pretraining (e.g., +27.8% on easy questions at R ≪ 1, Section 7) may shrink or reverse against a properly compute-optimal larger model. Furthermore, giving the larger model even a modest test-time compute budget (e.g., best-of-8 or best-of-32) would create a much stronger baseline — it is not obvious that a 2.6B model with compute-optimal test-time allocation should outperform a 14× larger model that also uses test-time compute, but this comparison is never tested. The paper's core claim about the substitution relationship between pretraining and inference compute is therefore quantified against an artificially weak baseline.

What evidence exists in the paper. The comparison methodology is described in Section 7. The paper explicitly states the parameter-only scaling choice and the greedy decoding used for the larger model. No experiments give the larger model any test-time compute budget. Figure 9 shows all comparisons against this single baseline configuration.

Mitigation status. The authors acknowledge that compute-optimal pretraining would scale both data and parameters and leave this to future work. No sensitivity analysis is performed (e.g., "how much test-time compute would the larger model need to match or exceed the smaller model's compute-optimal performance?"). The baseline choice is partially justified by representing "a canonical approach to scaling pretraining compute," but the omission of any test-time compute for the larger model makes the FLOPs-matched comparison most favorable to the test-time compute approach. A fairer comparison would allocate some portion of the larger model's inference budget to test-time strategies, since the paper's entire argument is that inference compute should be optimized — this principle applies to models of all sizes.

Sequential Revisions Introduce Latency That Parallel Strategies Avoid — The Wall-Clock Time Tradeoff Is Not Characterized

The assumption or constraint. The paper measures compute in "generations" (number of complete solutions sampled), which is a reasonable proxy for total FLOPs but ignores latency. Sequential revisions are inherently serial — each revision depends on the previous one — while parallel best-of-N can be executed simultaneously with sufficient hardware. Section 6.1 describes the revision model generating chains of up to 64 sequential revisions, and the compute-optimal policy often favors sequential-heavy strategies on easy problems (Figure 7, left, shows fully sequential is optimal at low budgets).

The consequence. A strategy that allocates 128 generations as 64 sequential × 2 parallel chains takes roughly 64× longer wall-clock time than one that runs 128 parallel samples simultaneously. For latency-sensitive applications — interactive assistants, real-time decision-making, online evaluation pipelines — the sequential-heavy strategies favored by the compute-optimal policy on easy problems may be impractical regardless of their accuracy advantages. The paper's optimization objective (Equation 1) maximizes accuracy subject to a generation budget constraint, but it does not include a latency term. A practitioner deploying this for interactive use would need to consider a different optimization: maximize accuracy subject to a wall-clock time budget, which would shift the optimal strategy toward parallel sampling even on easy problems.

What evidence exists in the paper. Figure 6 (right) compares sequential vs. parallel performance at matched generation budgets. Figure 7 (left) shows that at low budgets, fully sequential is optimal in terms of accuracy per generation. However, no latency measurements are reported — no wall-clock time comparisons between sequential and parallel strategies at matched hardware, no accounting for the serial dependency of revision chains, and no discussion of how latency constraints would alter the compute-optimal policy. The paper's efficiency metrics (videos/hour in Table 2, memory in Figure 7b) measure throughput and memory, not per-query latency.

Mitigation status. The paper does not address this tradeoff. It is mentioned neither in limitations (Section 8) nor in the experimental design. The compute-optimal framework as formalized in Equation 1 optimizes only for accuracy per generation, with no consideration of latency. A practitioner could partially mitigate this by running multiple independent sequential chains in parallel (up to hardware limits), but the fundamental serial dependency within each chain means sequential strategies will always have higher latency than parallel ones at matched total generation count. This is an inherent tradeoff that the paper's framework does not resolve — it optimizes for throughput efficiency, not latency efficiency.

The Revision Model's 38% Correct-to-Incorrect Reversion Rate — A Fundamental Training Distribution Mismatch

The assumption or constraint. The revision model is trained exclusively on sequences where all in-context answers are incorrect followed by a correct target (Section 6.1). This means the model never sees examples of what to do when the current answer is already correct — it has no training signal for "recognize that the current answer is correct and do not revise it." Section 6.1 reports:

"approximately 38% of correct answers get converted back to incorrect ones using a naive approach."

The consequence. In a long revision chain, the model can oscillate: produce a correct answer → revise it to an incorrect one → revise back to a correct one → etc. This means the final revision in a chain is not guaranteed to be the best one, and the system must rely on post-hoc selection mechanisms (majority voting or verifier-based selection across all revisions in the chain) to pick the best answer. These selection mechanisms are imperfect — the verifier itself has error rates, and majority voting requires multiple chains to be effective. The 38% reversion rate introduces a hard ceiling on how much sequential revisions can improve accuracy: beyond a certain chain length, the gains from additional revisions are offset by the probability of reverting correct answers. This is visible in Figure 6 (left), where pass@1 plateaus around 24-25% after ~15-20 steps and does not continue to improve out to 64 steps.

What evidence exists in the paper. Figure 6 (left) shows the revision model's pass@1 trajectory plateauing. The 38% figure is reported in Section 6.1. The paper discusses the mitigation (within-chain selection via verifier or majority voting) and reports that this brings sequential revision performance above parallel sampling (Figure 6, right), but the fundamental cause — the training distribution mismatch — is not resolved.

Mitigation status. The paper mitigates the symptom (using within-chain selection rather than taking the final revision) but does not address the root cause. The authors do not attempt to train the revision model on trajectories that include correct answers in context (e.g., "current answer is correct → do nothing" or "current answer is correct → output the same answer"), which would teach the model to recognize when revision is unnecessary. The ReST^EM experiment (Appendix K, Figure 16) suggests that even more sophisticated revision training can backfire, indicating the problem is non-trivial. Future work on training revision models that can detect correctness would directly address this limitation, but the current approach accepts the reversion rate as a cost of the training data construction and patches around it with post-hoc selection.

7. Implications and Future Directions

How This Work Changes the Landscape

SANA-WM shifts the field's understanding of what is necessary for long-horizon camera-controlled video generation by demonstrating that native minute-scale 720p world modeling with precise 6-DoF control is achievable under a compute budget that is accessible to academic labs and smaller research groups. This is not a paradigm shift in the sense of introducing a fundamentally new learning principle or theoretical framework. Rather, it is a systems-level reframing that challenges the implicit assumption — reinforced by recent large-scale systems like Sora, MovieGen, and Cosmos — that long-horizon video generation with precise action control requires industrial-scale compute, massive proprietary datasets, and models in the 5B–14B+ parameter range with multi-GPU inference.

The reframing is: efficiency is not a constraint to be worked around after achieving capability, but a design principle that, when applied systematically across the full stack (VAE, attention, conditioning, generation pipeline), enables capabilities that are otherwise inaccessible at a given compute level. The paper demonstrates this concretely: an all-softmax variant of SANA-WM cannot fit a 60-second 720p video on a single H100 (Figure 7b), meaning the hybrid GDN/softmax design is not merely faster — it is a feasibility requirement for single-GPU minute-scale generation. This flips the narrative from "efficiency lets us do the same thing cheaper" to "efficiency lets us do things that are otherwise impossible under our resource constraints."

Resolving or reframing prior tensions. The paper resolves a specific tension between two lines of work: efficient short-video generation (SANA-Video, LTX-Video) that achieves high quality on 5–10 second clips but cannot scale to minutes due to attention memory limitations and recurrent state drift, and long-horizon world models (HY-WorldPlay, LingBot-World) that achieve minute-scale rollouts but require resources that exclude most researchers. Prior to SANA-WM, these lines appeared to represent a fundamental tradeoff — you could have efficiency or long-horizon capability, but not both. SANA-WM demonstrates that this tradeoff is not fundamental but architectural: the specific failure modes at the intersection of efficiency and long horizons (cumulative linear attention drift at scale, spatial token explosion in frame-wise recurrence, intra-stride motion loss from aggressive VAE compression) have identifiable, solvable causes. The paper's four co-designed components (hybrid GDN/softmax, 1/√(D·S) key scaling, dual-rate camera control, long-video refiner) each address a specific failure mode that would otherwise prevent the combination of efficiency and capability.

What becomes more attractive. Several research directions are validated and accelerated by this work:

  • Architecture-first efficiency for video generation is shown to be a viable alternative to scale-first approaches. The paper's demonstration that a 2.6B model with carefully designed architecture can match or exceed 5B–14B baselines on specific capabilities (camera control accuracy, Table 2) strengthens the case that architecture innovation — not just parameter scaling — is a high-leverage research investment in video generation.
  • High-compression VAEs for long-horizon generation are validated as a foundation for accessible world modeling. The LTX2 VAE's 8× improvement over Wan2.1-VAE and 2× improvement over ST-DC-AE (Section 3.1) is shown to be quality-neutral (Table 3) while being the key enabler that makes 961-frame training feasible. This provides a clear target for future VAE research: compression ratios that enable new capabilities (minute-scale, 720p) without degrading quality.
  • Recurrent attention architectures for video are demonstrated to be not just faster but necessary for specific deployment scenarios (single-GPU minute-scale generation). The GDN key scaling analysis (Section 3.2, Figure 6) establishes a design principle — spatial token count must appear in recurrent state normalization — that any future frame-wise recurrent video architecture must respect.
  • Two-stage pipelines with specialized refiner models are validated as a practical strategy for closing the quality gap between efficiency-constrained base models and larger-scale systems. The refiner ablation (Table 5, Appendix A) shows that the refiner is not cosmetic but necessary — a general-purpose refiner actively damages quality at the minute scale, while an adapted refiner recovers both visual quality and camera control accuracy.

What becomes less attractive. The paper also delimits what efficiency-first design cannot achieve, which is equally important for directing research effort:

  • Naive scaling of short-context models to long horizons (via autoregressive extension without native long-context training) is implicitly challenged. The paper explicitly argues that short-horizon teachers provide "limited supervision for minute-scale scene persistence and trajectory following" (Section 1). While not empirically tested against a short-to-long distillation baseline, the paper's position is that native minute-scale training is necessary for genuine long-horizon consistency. This suggests that training on the longest sequences that fit in memory — rather than training on short sequences and extending at inference — is the more promising path, and the paper provides the efficiency tools (hybrid attention, high-compression VAE) to make this feasible.
  • Pose annotation pipelines that rely on proprietary or human-labeled data are made less necessary by the paper's demonstration that public video with automated metric-scale pose recovery (VIPE + Pi3X + MoGe-2, Section 4) yields sufficient training data for precise camera-controlled generation. The ~213K-clip corpus is described in enough detail (Appendix B, Table 6) to be reproducible, lowering the data barrier for future world-model work.
  • All-softmax attention for long videos is rendered less attractive as a research direction for resource-constrained settings, since Figure 7b shows it fundamentally cannot fit in single-GPU memory at 60 seconds. The research question shifts from "how to optimize softmax attention for long videos" to "what is the optimal combination of recurrent and exact attention blocks for a given memory budget" — a different and more tractable question given the paper's demonstration that hybrid architectures work well.

A methodological contribution beyond the system. The paper's progressive training strategy (four stages, each validating one architectural change at short sequence lengths before scaling, Section 3.1) provides a template for future work on efficient video architectures. The explicit validation of each component at 5-second clips (Table 3, Table 4, Appendix E.2) before committing to the expensive 60-second training stage is a practical methodology that makes architecture search for long-video models feasible without requiring full-scale training for every ablation.

Follow-Up Research This Work Enables

Scaling the model and data to test the efficiency-vs-capability tradeoff at larger scales. The paper demonstrates that a 2.6B model trained on ~213K clips can achieve competitive performance, but where does this efficiency advantage saturate? A natural follow-up would train SANA-WM variants at 5B, 10B, and 20B parameters with proportionally larger datasets, measuring how camera control accuracy and visual quality scale with model size under the same architectural constraints (hybrid GDN/softmax, dual-branch camera control, LTX2 VAE). The key question is whether the efficiency advantage of the architecture persists at larger scales (does a 10B SANA-WM match a 14B LingBot-World-style model trained on industrial data?) or whether the architecture's benefits are specific to the resource-constrained regime where alternative designs cannot fit in memory. A strong follow-up would report the full scaling curve (accuracy vs. model size) on the paper's benchmark, enabling a direct comparison with the scaling behavior of softmax-only architectures at matched parameter counts. The paper's training time (15 days on 64 H100s) suggests a 10B variant would take ~2.5 months on the same hardware — feasible for a well-resourced academic group.

Ablating the hybrid GDN/softmax ratio to characterize the memory-precision tradeoff. The paper uses a single hybrid configuration (15 GDN blocks + 5 softmax blocks at layers {3, 7, 11, 15, 19}, Section 5.1) and justifies it conceptually (softmax blocks as periodic memory-refresh checkpoints) but never ablates the ratio. A systematic study varying the number of softmax blocks from 1 to 20 (all-softmax, where memory permits) at a fixed total parameter count, and measuring both camera control accuracy and visual quality on the 60-second benchmark, would answer several open questions: (1) Is there a Pareto frontier where adding softmax blocks improves accuracy but increases memory, and where does the knee of the curve lie? (2) Does the optimal ratio depend on sequence length — i.e., do longer videos need more frequent exact-attention checkpoints? (3) Does placement (early vs. late vs. uniform) matter more than total count? The paper's conceptual framing (recurrent state as lossy memory, softmax as checkpoint) predicts that softmax blocks should be uniformly distributed and that performance should saturate after some number of blocks — testing this prediction would validate or refute the framing. The experiment requires training ~10 model variants at the 5-second scale first (as in the paper's Stage 2 methodology) and then scaling the best configurations to 60 seconds.

Training a difficulty-predicting model to close the exploration-exploitation gap in the annotation pipeline. The paper's difficulty estimation for test-time compute (2048 samples per question) is acknowledged as impractical for deployment. A concrete follow-up would train a lightweight classifier — possibly a fine-tuned Qwen3.5 VLM or a small transformer taking only the question text — to predict which of the five difficulty bins a new video scene belongs to, using the PRM's average final-answer score as training labels. The key metric is whether the classifier can achieve difficulty bin accuracy sufficient to preserve the compute-optimal scaling gains. Based on the paper's finding that predicted (model-based) difficulty bins perform nearly identically to oracle bins (Figures 4 and 8, the curves "largely overlap"), the required accuracy is likely modest — the system only needs to distinguish easy from hard, not precisely rank all five bins. A strong result would show that a classifier trained on video metadata (scene type, motion statistics, aesthetic scores from DOVER/VMAF/UniMatch — all of which are computable without generation) can match the PRM-based difficulty estimation at a fraction of the cost, making the compute-optimal allocation deployable. The paper's filtering pipeline (Appendix B.3) already computes many of these features, providing a natural feature set.

Extending the evaluation to truly out-of-distribution scenes and longer rollouts. The paper's benchmark uses 80 scenes from four categories (game, indoor, outdoor-city, outdoor-nature) generated by Nano Banana Pro — a controlled distribution. A stress-test would evaluate SANA-WM on real photographs from diverse sources (e.g., randomly sampled frames from SpatialVID test splits, user-uploaded photos, or images from different generative models) with the same 60-second trajectories. This would test whether the model's camera control and scene persistence generalize beyond the distribution of its training and benchmark images. A second stress-test would push the rollout length beyond 60 seconds — to 90s, 120s, and until the model fails — measuring whether the chunk-causal AR mechanism maintains quality indefinitely or eventually drifts. The paper's Figure 7b shows memory stays constant, but does the recurrent state's information content degrade over very long rollouts? Measuring ΔIQ and revisit PSNR at progressively longer durations would characterize the architecture's effective memory horizon, which is critical for practitioners planning deployments beyond 60 seconds. The paper already has the infrastructure: the same benchmark trajectories can be looped or extended, and the same evaluation metrics apply.

Combining SANA-WM's camera control with other action modalities. The paper demonstrates precise 6-DoF camera control, but world models for embodied AI typically require additional action modalities: robot joint angles, object manipulation commands, keyboard/gamepad controls, or language instructions (Section 2, the paper distinguishes these from camera control). A direct extension would add a second action-conditioning branch for, say, forward/backward/turn-left/turn-right discrete actions alongside the camera trajectory, training on a dataset that pairs camera motion with embodied actions (e.g., Sekai-Game data with both camera and gamepad actions, or DreamDojo-style robot videos with camera and arm trajectories). The key question is whether the dual-branch camera control design (UCPE + Plücker) can coexist with additional action modalities without interference, and whether the hybrid GDN/softmax backbone can simultaneously track global camera geometry and local object/agent dynamics. The ablation would compare: (1) multi-action conditioning with shared vs. separate attention branches, (2) training from scratch vs. fine-tuning the camera-control model on embodied data, and (3) whether camera control accuracy degrades when the model must also predict embodied actions. A negative result (camera control and embodied action control interfere) would be informative: it would suggest that different action modalities need separate architectural pathways, complicating unified world models.

Adversarial evaluation of the PRM to characterize verifier over-optimization in video generation. The paper identifies verifier over-optimization as a central bottleneck in text-based reasoning (Section 5.3: beam search degrades easy-problem performance at high budgets due to verifier exploitation), but this concept has not been studied in video generation. A direct follow-up would train a quality-assessment model (analogous to the PRM) on SANA-WM outputs — e.g., a classifier predicting VBench IQ scores from latent features — and then use it to guide search over generation parameters (guidance scale, noise schedule, sampling steps) or to filter among candidate rollouts. The hypothesis is that aggressive optimization against this verifier will lead to over-optimization: videos that score highly on automated metrics but are visibly worse to humans. The experiment would measure the correlation between verifier scores and human preference judgments at different optimization intensities, establishing the "reliability frontier" of automated quality assessment for video world models. A negative result (the verifier remains correlated with human judgment even under aggressive optimization) would suggest that video quality assessment is inherently harder to over-optimize than math-reasoning verification, potentially because visual artifacts are more globally constrained.

Practical Applications and Downstream Use Cases

Synthetic data generation for embodied AI and robotics training. The most immediate application of SANA-WM is generating diverse, camera-controlled video rollouts from single images to serve as training data for visual navigation, SLAM, and 3D reconstruction systems. The paper's 36× throughput advantage over LingBot-World (22.0 vs. 0.6 videos/hour on 8 H100s, Table 2) and single-GPU inference (51.1 GB, within an 80 GB H100 budget) means a single 8-GPU node can generate ~176 60-second videos per hour — over 4,000 videos per day. Each video comes with ground-truth camera trajectories (specified as input), enabling supervised training of pose estimation networks, depth predictors, and novel-view synthesis models on orders of magnitude more data than physically captured video datasets provide. The 720p resolution ensures the generated data is at sufficient quality for training production vision systems. The key advantage over prior synthetic data pipelines (e.g., rendering from 3D assets) is diversity: SANA-WM generates from single images, so a collection of diverse photographs (from anywhere) becomes a collection of diverse 3D-explorable scenes without requiring explicit 3D reconstruction or asset creation. The revisit memory results (PSNR 14.46/14.80 dB on Simple/Hard, Table 8) indicate that generated videos maintain sufficient consistency for loop-closure training — a critical capability for SLAM systems that prior short-horizon generators could not provide.

Interactive environment prototyping for game design and virtual production. The distilled SANA-WM variant (34 seconds per 60-second clip on a single RTX 5090, Figure 7a) approaches the latency needed for interactive preview: a designer provides a concept image and a rough camera path, waits ~30 seconds, and receives a minute-long 720p flythrough video exploring that space. While not real-time, this is fast enough for iterative design workflows where a designer generates multiple variants in a working session, compared to hours or days for traditional 3D modeling and rendering. The Hard-trajectory capability (loops, vertical motion, whip pans — Figure 4) means the system can prototype dynamic camera movements typical of film and game cinematography, not just smooth architectural walkthroughs. The single-GPU deployment on consumer hardware (RTX 5090) removes the need for cloud GPU access, making this workflow feasible for independent creators and small studios. The scene-static captioning protocol (Appendix D.1: prompts describe objects, layout, and lighting while omitting camera-motion language) means the designer controls camera motion through the trajectory input, not through prompt engineering — a cleaner separation of "what the scene contains" from "how the camera moves through it."

Benchmarking and evaluation infrastructure for long-horizon world models. The paper's benchmark (80 scenes × 2 trajectory splits, with defined metrics for camera control, visual quality, revisit memory, and temporal degradation, Section 5.2 and Appendix D) provides a standardized evaluation protocol that the field previously lacked. A research group developing a new world model can evaluate on this benchmark and compare directly against SANA-WM and the four baseline models in Table 2, using the same scenes, prompts, trajectories, and metric computation. This lowers the barrier to entry for world-model research: a group no longer needs to construct their own evaluation protocol from scratch, and results are comparable across papers. The benchmark's inclusion of both Simple and Hard trajectories (with explicit revisit pairs and temporal degradation windows) means systems cannot achieve high scores through short-horizon tricks — they must demonstrate genuine minute-scale persistence. The public release of benchmark metadata (scene images, prompts, calibrated intrinsics, metric trajectories, collision status, Appendix D.1) makes reproduction straightforward. The paper's documentation of the evaluation protocol (Appendix D.3: Pi3X pose recovery, Umeyama alignment, VBench custom-input mode, revisit pair timestamp matching) provides a reference implementation that others can replicate or adapt.

Efficient video compression and streaming research. The two-stage pipeline (2.6B stage-1 generator + 17B LoRA-adapted refiner) demonstrates a design pattern with applications beyond world modeling: a lightweight base model generates a plausible but imperfect output, and a heavier refinement model corrects specific artifacts without full regeneration. This pattern is directly applicable to video compression, where a lightweight decoder could produce a low-bitrate reconstruction and a heavier enhancement model could add perceptually important details. The paper's finding that a general-purpose refiner (original LTX-2.3) fails catastrophically at minute scale while an adapted refiner succeeds (Table 5: VBench Overall drops from 80.62 to 71.37 with the original refiner) provides a concrete lesson: refinement models must be trained on the specific distribution they will encounter, not on a generic high-quality distribution. The truncated flow-matching formulation (Section 3.4) and LoRA adaptation strategy (rank-384, multimodal base model) are described in sufficient detail to be applied to other base-refiner pairs. The efficiency numbers (74.7 GB peak memory with refiner vs. 51.1 GB without, 22.0 vs. 24.1 videos/hour throughput, Table 2) provide a baseline for the cost of adding a refinement stage — modest enough to be practical in many settings.

When to Prefer This Method

The paper does not present SANA-WM as the unconditionally best world model, but rather as a specific point on the efficiency-capability Pareto frontier. Based on the quantitative results and the paper's own framing, the decision to use SANA-WM over alternatives depends on the relative importance of three factors: camera control precision, inference efficiency, and visual quality ceiling.

  • Prefer SANA-WM when camera trajectory adherence is the primary requirement and inference must run on limited hardware. On both Simple and Hard trajectory splits, SANA-WM + refiner achieves the lowest rotation and translation errors among all compared methods (RotErr 4.50°/8.34° on Simple/Hard, Table 2), outperforming LingBot-World (10.47°/18.99°) by 2.3× on Simple and 2.3× on Hard, and HY-WorldPlay (17.89°/35.46°) by 4.0× and 4.3× respectively. This advantage is largest on Hard trajectories where simpler conditioning schemes fail. Moreover, SANA-WM achieves this accuracy with single-GPU inference (51.1 GB stage-1, 74.7 GB with refiner) at 720p, while the closest visual-quality competitor (LingBot-World) requires 454.1 GB across 8 GPUs and cannot affordably run 720p inference on the paper's evaluation budget. If the use case involves generating diverse camera paths through scenes for training or evaluation purposes, and the hardware budget is a single high-end GPU, SANA-WM is the only option among the compared systems that meets both the control accuracy and hardware constraints.

  • Prefer LingBot-World or similar industrial-scale systems when absolute visual quality is paramount and compute is abundant. LingBot-World achieves marginally higher VBench Overall (81.82 vs. 80.62 on Simple, tied at 81.89 on Hard, Table 2) and the best temporal stability (ΔIQ 0.04/0.58 on Simple/Hard vs. SANA-WM + refiner's 1.17/0.31, Table 8). Its explicit memory mechanisms appear to provide more stable scene persistence over the full minute. If the generated videos will be directly consumed by humans (e.g., for cinematic previsualization or public-facing demos) and a multi-GPU inference budget is available, LingBot-World's marginally higher visual quality and better stability may justify the 36× throughput penalty. However, this comparison is qualified: LingBot-World was evaluated at 480p in the benchmark (720p was infeasible), so the quality comparison at matched resolution remains open.

  • Prefer HY-WorldPlay or Infinite-World when geometric consistency or pose-free operation is valued over raw camera control accuracy. HY-WorldPlay achieves better revisit PSNR on Hard trajectories than Matrix-Game 3.0 (13.72 vs. 12.17, Table 8) despite worse camera control, suggesting its explicit geometric memory may better preserve scene structure at loop closures even when trajectory following drifts. Infinite-World's pose-free design (it does not require metric camera poses as input) makes it applicable when camera trajectories cannot be specified in metric coordinates — e.g., when conditioning on discrete navigation commands (forward, left, right) rather than precise 6-DoF paths. SANA-WM requires metric-scale camera trajectories as input, which limits its use to scenarios where such trajectories can be authored or extracted.

  • SANA-WM's distilled variant (34s/clip on RTX 5090) occupies a unique deployment niche that no baseline addresses. None of the compared systems can run on a consumer GPU at interactive-ish latencies. For applications where a designer iterates on camera paths with ~30-second turnaround — generating a preview, adjusting the path, re-generating — the distilled SANA-WM on a single consumer GPU is the only option among compared systems. The paper does not compare against real-time rendering engines (which achieve <100ms latency but require explicit 3D assets), so the appropriate comparator depends on whether scene authoring (from a single image) or rendering quality (from explicit geometry) is the bottleneck.