Vimoo 1.0: Video Generation for Compact, Lightweight, and High-Speed

Vimoo 1.0 Team

Abstract

Video generation models have advanced rapidly, but increasing model scale also leads to higher GPU memory consumption and longer inference latency. We present Vimoo 1.0, an efficient latent video generation model for text-to-video (T2V) and image-to-video (I2V) generation, aiming to explore how large-scale training can support these capabilities within a compact architecture. Vimoo 1.0 adopts an 11.7B-parameter dual-stream Multimodal Diffusion Transformer (MMDiT) with a pretrained text encoder and a highly compressed video variational autoencoder (VAE). It is jointly trained across resolutions and frame rates to generate 10-second 720p videos at 24 fps. A separately trained Enhancer then upscales the generated videos to 1080p. We further introduce Vimoo 1.0-Lite, a more compact variant that combines 2×2 spatial patchification in hidden space to achieve even greater inference efficiency. Overall, the Vimoo 1.0 family outperforms most current open-source models and is competitive with leading proprietary models. With few-step distillation and inference-system optimization, Vimoo 1.0 achieves up to a 1.2× speedup in video inference compared with the officially recommended settings of other models, while Vimoo 1.0-Lite provides a further 4.97× speedup over Vimoo 1.0.

1 Introduction

Over the past few years, video generation models have made substantial progress in visual quality, motion synthesis, and semantic control [12, 46, 16, 38, 44, 7, 37, 29], enabling applications in content creation, advertising, e-commerce, entertainment, and visual simulation. Despite these advances, generating videos that are visually coherent, physically plausible, and faithful to detailed instructions remains challenging [13, 53]. Such models must preserve fine-grained appearance, object identity, and scene geometry while synthesizing consistent motion and physical interactions over time.

Beyond generation quality, computational efficiency remains a major barrier to practical deployment. The number of spatiotemporal tokens grows with video resolution, frame rate, and duration, increasing the model's computational and memory demands. Larger diffusion transformers further increase parameter storage and per-step computation [27], while iterative denoising requires repeated model evaluations for each generated video [10]. Together, these factors lead to substantial GPU memory requirements, high serving costs, and long inference latencies, limiting deployment in interactive applications, large-scale services, and resource-constrained environments. Highly compressed video latents reduce the visual sequence length processed by diffusion transformers [8, 24].

To address these challenges, we present Vimoo 1.0, a model family that explores large-scale training within a moderate parameter budget. Our aim is to develop strong generation capabilities while keeping inference cost central to the design. Vimoo is trained for both T2V and I2V generation, with an emphasis on following instructions, learning physical and temporal relationships from videos, and producing visually appealing results. These goals guide the architecture, data preparation, and training process described in this report. Vimoo 1.0 employs a dual-stream MMDiT [5]. Visual tokens and text tokens retain separate feature-processing paths and exchange information through joint attention in every backbone block. This structure combines modality-specific transformations with interactions between the generated content and the conditioning signals. We adopt Qwen2.5-VL [2] for text representations and a high-compression Wan 2.2 VAE [41] for visual latents. These pretrained components provide informative conditioning and compact visual representations.

The training process is designed to use data at scale while considering differences in content, quality, and training efficiency. We process and organize image and video data, provide captions that describe both appearance and temporal behavior, and adjust data mixtures across stages. Training progresses through different resolutions and frame rates and combines text-to-image (T2I), T2V, and I2V tasks. Image training serves as useful visual initialization, while extensive video training is central to learning motion and interactions. We use Muon [15] for the main attention and feed-forward weight matrices and AdamW [23] for complementary parameter groups, with careful control of update scales and numerical stability. After pretraining, we refine the model using targeted high-quality data and learning-rate annealing. We further apply direct preference optimization (DPO) [30, 20] to encourage outputs that better match the preferences expressed in the training supervision.

To further improve inference efficiency, we introduce Vimoo 1.0-Lite. Spatial patchify and unpatchify modules shorten the visual sequence processed by the backbone, while a lower-rank, shared timestep representation reduces modulation parameters. Together, these changes reduce both sequence-related computation and model size, yielding a 4.97× inference speedup over Vimoo 1.0.

Alongside the base generators, we develop Vimoo 1.0 Enhancer to improve generated 720p videos and produce 1080p outputs at 24 fps. This separately trained model follows the same overall architectural design as the Vimoo 1.0 family. It combines the resolution and clarity enhancement associated with generative repair of defects in appearance and motion. The Enhancer can be applied to both the Vimoo 1.0 and the Lite variant, and our tests further show that it can enhance outputs from other video generation models.

Extensive experiments on T2V and I2V benchmarks demonstrate that Vimoo 1.0 achieves state-of-the-art performance among the compared systems in visual quality, temporal consistency, and prompt following. Despite its substantially lower computational cost, Vimoo 1.0-Lite delivers competitive generation quality, demonstrating that high-quality video generation and efficient deployment can be jointly optimized through the co-design of data, architecture, latent representation, training, and inference.

The main contributions of this work are summarized as follows:

  • A compact dual-stream multimodal architecture. We introduce an approximately 11.7B-parameter MMDiT-based video generation model with modality-specific projections, joint attention, and cross-modal conditioning for precise T2V and I2V generation.
  • A multi-stage training and optimization strategy. We introduce a joint T2V/I2V training framework that progressively improves visual fidelity, prompt adherence, temporal consistency, and sampling efficiency.
  • A high-quality and lightweight model family. Vimoo 1.0 achieves state-of-the-art T2V and I2V performance among the compared systems, while Vimoo 1.0-Lite enables near-real-time inference with comparable generation quality. A separately trained Enhancer complements both generators through generative repair and clarity enhancement.

2 Model Design

2.1 Overview

The Vimoo 1.0 family generates videos in a compressed visual latent space [31, 4]. A text encoder converts the prompt into conditioning features, which are projected and refined before entering the conditioning stream. The Wan 2.2 VAE maps images and videos into visual latents and decodes generated latents back into video. For I2V, the reference image supplies both semantic features and spatial latent information. A dual-stream MMDiT processes the noisy visual latents together with these conditions. Figure 1 summarizes the model architecture. The separately trained Enhancer operates on generated videos (Section 2.5).

Vimoo 1.0 architecture: Qwen2.5-VL encodes the text prompt, Glyph ByT5 v2 encodes optional character text, and SigLIP and the VAE encode an optional reference image. These conditions and projected noisy latents enter 40 dual-stream MMDiT blocks with joint attention, per-stream FFNs, and shared timestep modulation. After sampling, the VAE decoder produces the generated video.
Figure 1. Overview of the Vimoo architecture. Text and optional image conditions are encoded alongside noisy video latents. The dual-stream MMDiT exchanges information through joint attention, and the VAE decodes the sampled latents.

2.2 Dual-Stream MMDiT Backbone

The backbone contains 40 dual-stream Transformer [39] blocks. One stream processes visual latents, the other processes conditioning tokens, which can include text, character-related features, and reference-image semantics. Each stream has its own query, key, and value projections. The projected sequences are concatenated for joint attention, after which the outputs are split back into their respective streams. The two-stream design reflects the different origins of visual and conditioning features. Separate projections and FFNs allow each stream to transform its own representations, while joint attention allows information to pass between the streams at every layer. This design preserves modality-specific processing and information exchange throughout generation.

Timestep conditioning controls how the network processes features at different noise levels. A 256-dimensional sinusoidal timestep embedding is mapped to a 3072-dimensional representation by a two-layer MLP with an intermediate SiLU activation. We apply a SiLU activation followed by a linear projection to a 1536-dimensional bottleneck shared across all backbone blocks. Each block maintains a separate linear projection for each stream, mapping this shared representation directly to six 3072-dimensional vectors: shift, scale, and gate for the attention and FFN branches. Shift and scale modulate normalized features, while the gates control each branch's contribution to the residual update [27, 5]. The final output head uses a separate modulation path that derives shift and scale directly from the original 3072-dimensional timestep representation.

We use three-dimensional rotary position embeddings (RoPE) [36] to represent temporal, vertical, and horizontal positions. In our configuration, the 128 dimensions of each head are allocated as 16, 56, and 56 dimensions along these axes. Rotary embeddings are applied to the visual queries and keys, not to the conditioning stream. Vimoo 1.0 T2V, I2V, and Lite all use a T/H/W adaptation of YaRN [28] for training across spatial and temporal settings.

Normalization serves two distinct roles. LayerNorm [1] precedes the attention and FFN transformations, with conditional shifts and scales supplied by timestep modulation. Separately, queries and keys are normalized using RMSNorm [51] within each attention head, with distinct learned scale parameters. Controlling query and key magnitudes helps limit excessive attention-logit scales. In our training experience, QK normalization was important for stabilizing attention, including when using Muon.

2.3 Text and Image Conditioning

The conditioning and visual components are listed below. Here, "tokenizers" covers continuous encoders, adapters, and discrete tokenization.

  • Text encoder. Qwen2.5-VL [2] provides semantic representations of the prompt. It then projects 3,584-dimensional text features to the backbone width of 3,072.
  • Text token refiner. A two-layer module inside the denoiser adapts text tokens using self-attention and SiLU FFNs. Its conditioning combines a separate timestep embedding with projected, pooled text features. Unlike the main backbone, the refiner uses LayerNorm, gate-only modulation, and no QK normalization.
  • Character representation. Glyph-ByT5-v2 [22, 45] supplies fine-grained character-related features that complement the prompt's semantic representation. Its 1,472-dimensional features are normalized and mapped to 3,072 dimensions, then supplied as a separate group of conditioning tokens.
  • Reference-image semantics. SigLIP [50] encodes semantic features of the reference image. A normalization and MLP adapter maps the 1,152-dimensional interface to the conditioning width. This semantic path complements the spatial reference information carried by VAE latents.
  • Visual VAE. We use the Wan 2.2 VAE variant with temporal, height, and width compression factors of 4 × 16 × 16 [41]. It encodes visual content into a compact latent space and decodes generated latents. The denoiser uses 48 latent channels.

The visual input combines 48 noisy-latent channels, 48 conditioning-latent channels, and one mask channel, giving 97 input channels. The output has 48 channels. Text, character, and image-semantic features enter the conditioning stream after their respective adapters, with embeddings identifying the condition type. Reference latents enter through the visual path, providing a separate route for spatial reference information.

2.4 Vimoo 1.0-Lite

Vimoo 1.0-Lite introduces two changes while retaining the 40-block dual-stream backbone. The first reduces the visual sequence length through spatial patchification in hidden space. After the input projection, four neighboring hidden vectors in each 2 × 2 spatial region are concatenated and linearly mapped from four times the hidden width back to the original width. The temporal axis is not merged. For an evenly divisible spatial grid, the backbone therefore processes one quarter as many visual tokens. After the backbone, an unpatchify projection expands each hidden vector to four position-specific outputs. The restored spatial layout then passes through final normalization, modulation, and the output projection. Our purpose is to use the backbone's learned capacity on a shorter sequence while retaining a fine-grid latent output. The second change further compresses timestep modulation by narrowing the shared bottleneck. Vimoo 1.0 uses a shared 3,072-to-1,536 projection, followed by 80 independent 1,536-to-18,432 output projections. The Lite model retains this structure but reduces the bottleneck width from 1,536 to 16. Both models share the bottleneck representation across all blocks and both streams, while retaining a separate output mapping and bias for each block and stream. This design builds on the shared timestep representation already used in Vimoo 1.0, exploring whether a much narrower bottleneck can provide sufficient conditioning information. For the Lite model, the backbone modulation parameters decrease from 2.271 billion to 0.025 billion. Including Lite model's added merge and split modules, the total diffusion transformer count falls from approximately 11.7 to 9.5 billion parameters.

2.5 Vimoo 1.0 Enhancer

Generative video enhancement and restoration methods aim to improve visual detail while maintaining temporal consistency [9, 43, 42].

Vimoo 1.0 Enhancer is a separately trained generative video enhancement model that follows the same overall network architecture as the Vimoo 1.0 family. It takes generated 720p video as its input and produces enhanced video at 1080p and 24 fps. It can enhance outputs from both Vimoo 1.0 and Vimoo 1.0-Lite and is also suitable for most 720p videos.

The model provides two complementary functions: 1) Generative repair. The Enhancer is designed to correct defects already present in generated content, including malformed fine details, hand and facial artifacts, ripple-like distortions during motion, and implausible motion. 2) Resolution and clarity enhancement. The Enhancer improves visual quality, sharpness, and fine-detail rendition while increasing the output resolution from 720p to 1080p. Overall, the Enhancer repairs visual artifacts and improves resolution, sharpness, and fine detail.

3 Training Strategy

We cover the backbone MMDiT's training objective, recipe, optimization, and post-training, then the separately trained Enhancer and distributed training.

3.1 Training Objective and Joint Learning Tasks

We train in the visual latent space using flow matching [18]. The network predicts a conditional velocity field from the current noisy state and timestep, with text and, where applicable, reference-image information. This formulation provides a common generative objective for image and video training, while the data and conditioning determine the task presented to the model.

Our training includes T2I, mixed T2I/T2V, and mixed T2V/I2V tasks. T2I training provides an initial basis for learning subject appearance, scene structure, composition, and correspondence with text. T2V is central to the acquisition of the model's basic video-generation capabilities. Large amounts of video data are needed to learn how actions unfold, how objects interact, and how scene appearance changes with camera movement. I2V further extends generation to scenarios in which a user supplies a reference image. The model must use its appearance and content while generating motion consistent with the text condition. Joint T2V/I2V training supports both conditioning modes, making image-conditioned task organization important to training.

3.2 Progressive Training with Mixed Resolutions and Frame Rates

Prior video diffusion work has explored staged training from images to videos, followed by refinement on high-quality video data [3].

For our Vimoo 1.0 family, training starts at lower resolution with broad data coverage and progressively places greater emphasis on visual detail and quality. As training advances, data quality increases while the range and volume of selected data become more focused. This progression is intended to use computation efficiently: broad visual and semantic knowledge can be learned before concentrating more of the budget on higher-resolution refinement.

Table 1 lists the training settings. Training begins with 256p images, followed by image/video mixtures at 256p and then 480p. A mixed-setting stage combines 480p at 16 fps, 480p at 24 fps, and 720p at 16 fps. Training subsequently continues at 720p and 24 fps, followed by two SFT stages. Early stages establish broad visual representations and semantic associations, while video data supplies temporal and interaction knowledge. Higher-resolution data places greater demands on fine detail and visual consistency. In the mixed-setting stage, 480p data provides an economical setting for learning plausible dynamics, while 720p data supplies finer visual information.

Table 1. Progressive training settings. Task-to-stage mappings and version-specific branches are not disclosed. B and M denote billion and million samples. Data volumes are not summed across stages.
StageResolution, fps, durationData volumeEpochs
PT 1256p images2B images2
PT 2256p, 16 fps, 2–10 s1B images / 200M videos5
PT 3480p, 16 fps, 2–15 s500M images / 100M videos3
PT 4480p, 16/24 fps; 720p, 16 fps; 2–30 s50M videos2
PT 5720p, 24 fps, 5–30 s10M videos2
SFT 1720p, 24 fps, 5–30 s5M videos3
SFT 2720p, 24 fps, 5–30 s2M curated videos3

A practical difficulty in mixed training is maintaining a consistent interpretation of spatial and temporal positions. In our earlier experiments, the position-extension schemes we tested could degrade generation quality when resolution or temporal settings changed. Resolution transitions sometimes required the model to relearn aspects of its prior behavior. We address this issue with a T/H/W adaptation of YaRN [28], adjusting positional representations along the temporal and both spatial axes. The intention is to let a shared backbone learn from videos with different spatial scales and temporal sampling densities. We use this approach across the whole Vimoo 1.0 family. In our training experience, this eased adaptation to changing settings and improved mixed training.

3.3 Muon and AdamW Optimization

Early optimizer comparisons motivated the use of Muon [15, 21] for large-scale training. In our setup, it improved convergence speed and helped overall training stability. We use Muon for the matrix parameters of the backbone attention and FFN layers. AdamW [23] handles the modulation layers and input/output layers, as well as non-matrix parameters such as biases and normalization scales.

Combining the optimizers requires coordinating their update scales. Their hyperparameters affect different parts of the network, so tuning either optimizer in isolation can produce imbalanced updates. We monitor parameter-update magnitudes and gradient values when adjusting the training settings. We keep this description at the level of balancing updates across parameter groups, without imposing a single update-ratio formula or a fixed relationship between their learning rates.

Faster convergence does not eliminate numerical-scale risks. During Muon training, we observed growth in some parameter norms and activation magnitudes. We therefore track parameter norms and activation RMS values across the network and adjust the training strategy when necessary. Controls on activation and parameter magnitudes, together with the QK normalization described in Section 2.2, help manage this behavior.

Last but not least, validation loss can usually guide stage progression. In addition to its aggregate trend, we monitor loss across noise timesteps and video categories to avoid relying on an average that may hide uneven learning. When validation loss stabilizes, we increase the batch size or reduce the learning rate, and continue training before moving to the next stage. Our target is sufficient convergence for that stage, rather than an assertion of mathematical optimality.

3.4 Post-Training and Model Refinement

After large-scale pretraining, we use targeted high-quality training to address capabilities that remain insufficiently learned. We first assess these areas and then adjust the data distribution and sampling mixture to increase the model's exposure to the relevant content. This uses the retrieval and mixture-organization capabilities built within our data pipeline. For broader quality refinement, we construct a more selective supervised fine-tuning (SFT) set with attention to visual quality, motion quality, caption accuracy, and cinematographic content. Training uses learning-rate annealing and maintains an exponential moving average (EMA) of model weights. Annealing reduces the update scale during refinement, while EMA smooths the sequence of model-weight updates. We also perform targeted DPO to shift generation toward the desired preferences [30, 40, 20].

3.5 Enhancer Training

We initialize the Enhancer with pretrained weights from Vimoo 1.0 to leverage its generative capabilities for video repair. Unlike text-conditioned video generation, enhancement should preserve the content of the input video rather than follow the customized text prompt. We therefore replace variable text prompts with a short, fixed sequence of text tokens throughout training and inference. We do not apply condition dropout for classifier-free guidance (CFG) during training or use CFG at inference.

The low-quality video serves as the conditioning input, using the concat injection mechanism similar to that of the I2V model. During training, the model learns to denoise a noisy version of the high-quality target video, conditioned on the corresponding low-quality input. We find that retaining a multi-step denoising process is important for effective generative repair. However, the number of denoising steps can be reduced through suitable acceleration methods.

3.6 Distributed Training and Engineering Optimization

We train the MMDiT backbone using a distributed training stack built on Megatron Core [34, 26]. The large model and long visual token sequences place high demands on computation and memory. We distribute the training workload across devices and optimize data loading and workload balancing to accommodate samples with different resolutions and lengths. These optimizations help reduce idle time caused by data loading delays and uneven workloads. We also optimize operators and execution to reduce memory traffic and training overhead.

4 Model Performance

We conduct human assessments of instruction following, frame aesthetics, visual quality, and motion, providing a fine-grained analysis of model capabilities. To comprehensively assess video generation capabilities, we introduce Vimoo-VBench, a human evaluation benchmark designed to evaluate video generation models in the market.

Vimoo-VBench comprises 500 carefully curated prompts spanning diverse content categories, including advertising, social media content, narrative storytelling, educational content, and entertainment. The prompts are designed to test models across varying complexity levels, from single-shot scenarios to complex multi-shot sequences. Prompts cover a wide range of subjects (humans, animals, objects, abstract concepts), environments (indoor, outdoor, natural, urban), and temporal dynamics (static, slow-motion, fast-action sequences).

Table 2. T2V human assessment results.
MetricWan 2.2 [41]LTX 2.5 [17]Veo 3.1 [6]Vimoo 1.0-LiteVimoo 1.0
Overall23%27%34%32%35%
Instruction following58%60%85%71%83%
Frame aesthetics78%77%82%87%91%
Visual quality81%82%88%84%88%
Motion effects52%55%69%51%53%
Table 3. I2V human assessment results.
MetricWan 2.2 [41]LTX 2.5 [17]Veo 3.1 [6]Vimoo 1.0-LiteVimoo 1.0
Overall30%35%44%41%47%
Image-video consistency70%65%84%80%89%
Instruction following56%64%88%88%90%
Frame aesthetics80%77%84%81%89%
Visual quality83%86%93%89%91%
Motion effects61%65%77%59%63%

We use rating-based evaluation to examine instruction following, frame aesthetics, visual quality, and motion effects for T2V. The I2V table additionally measures image-video consistency. Tables 2 and 3 show the evaluation results for T2V and I2V, respectively. These results indicate that Vimoo achieves superior frame aesthetics and visual quality compared with the other models, while remaining competitive in instruction following and motion effects. Such a comprehensive benchmark suite serves as a practical tool for uncovering the weaknesses of a model and determining which aspects require further refinement. Detailed performance analysis guides more effective optimization, iteratively improving overall quality and alignment with task requirements.

5 Inference Speed and GPU Memory Requirements

Vimoo applies inference acceleration at both the model and system levels. Removing classifier-free guidance (CFG) [11] eliminates the extra unconditional forward pass, while few-step distillation reduces the number of denoising iterations. Progressive distillation, consistency models, and distribution matching distillation provide background on few-step generation [33, 35, 48, 47, 49]. Table 4 reports the inference times across CFG and sampling-step settings. Compared with the officially recommended settings of other models, Vimoo achieves an approximately 1.2× speedup, comparable to top-tier models.

We apply the same acceleration strategy to Vimoo 1.0-Lite, together with hidden-space token compression and a streamlined inference path. At eight steps without CFG, the measured times are 48.2s for Vimoo 1.0 and 9.7s for Lite, yielding a 4.97× speedup over Vimoo 1.0.

Table 4. Inference time in seconds. CFG indicates an additional unconditional model evaluation. Resolution and frame count differ across some baselines. The inference steps follow the officially recommended settings of the respective models.
ModelCFGStepsResolutionFramesTime (s)
Wan 2.2 [41]Yes501280 × 720121490
MiniMax H3 [25]No201344 × 76812460
LTX 2.5 [17]Yes401280 × 704121140
Vimoo 1.0-LiteYes501280 × 720121130
No501280 × 72012160.6
No81280 × 7201219.7
Vimoo 1.0Yes501280 × 720121480
No501280 × 720121260
No81280 × 72012148.2

We further optimize Vimoo for deployment on lower-end GPUs. At the kernel and operator levels, we employ SageAttention [52, 32] quantization to reduce memory traffic and improve hardware utilization. We also apply kernel fusion and operator optimization, together with feature caching [19] during diffusion sampling to reuse intermediate features at non-critical steps and avoid redundant computation. These optimizations target practical acceleration while preserving nearly identical output quality. Table 5 reports separate timings by device.

In parallel, we reduce peak GPU memory through pipeline offloading, group offloading, and VAE tiling. General descriptions of these memory-saving techniques are available in the Diffusers documentation [14]. With these techniques enabled, the complete T2V/I2V pipeline can generate a 720p, 121-frame video with a peak memory consumption of approximately 13.6 GB, enabling end-to-end inference on a single consumer-grade GPU such as the NVIDIA RTX 4090.

Table 5. Device-level inference time in minutes.
ModelParams.5090 (m)4090 (m)4070 (m)M4 (m)
MiniMax H3 [25]33B3.44.69.5642
LTX 2.5 [17]22B2.43.826.2600
Vimoo 1.0-Lite9.5B0.750.821.9621.3
Vimoo 1.011.7B2.674.26.68565

6 Conclusions

We presented Vimoo 1.0, a compact approximately 11.7B-parameter video generation model for T2V and I2V generation. By combining large-scale curated data, a dual-stream MMDiT architecture, high-ratio spatiotemporal compression, and multi-stage joint training, Vimoo achieves top-tier performance in visual quality, prompt adherence, and temporal consistency. We further release Vimoo 1.0-Lite, which uses more aggressive token compression and an inference-optimized pipeline to enable near-real-time generation while maintaining comparable quality. We also introduce Vimoo 1.0 Enhancer, a separately trained generative model that extends the pipeline from 720p generation to 1080p enhancement through artifact repair and clarity improvement. Together, these components reflect our approach to jointly optimizing video quality and inference efficiency through data, architecture, representation, training, and inference.

References

  1. [1]
    Ba, J.L., Kiros, J.R., Hinton, G.E.: Layer Normalization. arXiv:1607.06450 (2016), https://arxiv.org/abs/1607.06450v1
  2. [2]
    Bai, S., et al.: Qwen2.5-VL technical report. arXiv:2502.13923 (2025), https://arxiv.org/abs/2502.13923
  3. [3]
    Blattmann, A., Dockhorn, T., Kulal, S., et al.: Stable Video Diffusion: Scaling Latent Video Diffusion Models to Large Datasets. arXiv:2311.15127 (2023), https://arxiv.org/abs/2311.15127v1
  4. [4]
    Blattmann, A., Rombach, R., Ling, H., Dockhorn, T., Kim, S.W., Fidler, S., Kreis, K.: Align your latents: High-resolution video synthesis with latent diffusion models. In: Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (2023), https://arxiv.org/abs/2304.08818v2
  5. [5]
    Esser, P., et al.: Scaling rectified flow transformers for high-resolution image synthesis. arXiv:2403.03206 (2024), https://arxiv.org/abs/2403.03206
  6. [6]
    Google DeepMind: Veo 3 model card. Official model card (2026), https://storage.googleapis.com/deepmind-media/Model-Cards/Veo-3-Model-Card.pdf?generation=1774536664344117, updated 13 January 2026
  7. [7]
    HaCohen, Y., Brazowski, B., Chiprut, N., et al.: LTX-2: Efficient joint audio-visual foundation model. arXiv:2601.03233 (2026), https://arxiv.org/abs/2601.03233v1
  8. [8]
    HaCohen, Y., Chiprut, N., Brazowski, B., et al.: LTX-Video: Realtime video latent diffusion. arXiv:2501.00103 (2024), https://arxiv.org/abs/2501.00103v1
  9. [9]
    He, J., Xue, T., Liu, D., Lin, X., Gao, P., Lin, D., Qiao, Y., Ouyang, W., Liu, Z.: VEnhancer: Generative space-time enhancement for video generation. arXiv:2407.07667 (2024), https://arxiv.org/abs/2407.07667v1
  10. [10]
    Ho, J., Jain, A., Abbeel, P.: Denoising Diffusion Probabilistic Models. arXiv:2006.11239 (2020), https://arxiv.org/abs/2006.11239v2
  11. [11]
    Ho, J., Salimans, T.: Classifier-Free Diffusion Guidance. arXiv:2207.12598 (2022), https://arxiv.org/abs/2207.12598v1
  12. [12]
    Ho, J., Salimans, T., Gritsenko, A., et al.: Video Diffusion Models. arXiv:2204.03458 (2022), https://arxiv.org/abs/2204.03458v2
  13. [13]
    Huang, Z., He, Y., Yu, J., et al.: VBench: Comprehensive Benchmark Suite for Video Generative Models. arXiv:2311.17982 (2023), https://arxiv.org/abs/2311.17982v1
  14. [14]
    Hugging Face: Diffusers v0.35.1: Reduce Memory Usage. https://huggingface.co/docs/diffusers/v0.35.1/en/optimization/memory, accessed 1 October 2026; background on offloading and VAE tiling
  15. [15]
    Jordan, K., et al.: Muon: An optimizer for the hidden layers of neural networks. https://github.com/KellerJordan/Muon, accessed 22 September 2026; exact implementation revision to be confirmed
  16. [16]
    Kong, W., Tian, Q., Zhang, Z., et al.: HunyuanVideo: A Systematic Framework For Large Video Generative Models. arXiv:2412.03603 (2024), https://arxiv.org/abs/2412.03603v6
  17. [17]
    Lightricks: LTX-2.5: Video, audio & world simulation. Official model card, Hugging Face (2026), https://huggingface.co/Lightricks/LTX-2.5/blob/6c7e5e573ac1667efc83407806fe9b0b93730e60/README.md, accessed 7 October 2026
  18. [18]
    Lipman, Y., et al.: Flow matching for generative modeling. arXiv:2210.02747 (2022), https://arxiv.org/abs/2210.02747
  19. [19]
    Liu, F., Zhang, S., Wang, X., et al.: Timestep Embedding Tells: It’s Time to Cache for Video Diffusion Model. arXiv:2411.19108 (2024), https://arxiv.org/abs/2411.19108v2
  20. [20]
    Liu, J., Liu, G., Liang, J., Yuan, Z., Liu, X., Zheng, M., Wu, X., Wang, Q., Xia, M., Wang, X., Liu, X., Yang, F., Wan, P., Zhang, D., Gai, K., Yang, Y., Ouyang, W.: Improving video generation with human feedback. In: Advances in Neural Information Processing Systems. vol. 38 (2025). https://doi.org/10.52202/085713-2750, https://proceedings.neurips.cc/paper_files/paper/2025/hash/76227feb18ea0ee40bd15cf02c33e18e-Abstract-Conference.html
  21. [21]
    Liu, J., Su, J., Yao, X., et al.: Muon is scalable for LLM training. arXiv:2502.16982 (2025), https://arxiv.org/abs/2502.16982v1
  22. [22]
    Liu, Z., Liang, W., Zhao, Y., Chen, B., Liang, L., Wang, L., Li, J., Yuan, Y.: Glyph-ByT5-v2: A strong aesthetic baseline for accurate multilingual visual text rendering. arXiv:2406.10208 (2024), https://arxiv.org/abs/2406.10208
  23. [23]
    Loshchilov, I., Hutter, F.: Decoupled weight decay regularization. In: International Conference on Learning Representations (2019), https://arxiv.org/abs/1711.05101
  24. [24]
    Ma, G., Huang, H., Yan, K., et al.: Step-Video-T2V technical report: The practice, challenges, and future of video foundation model. arXiv:2502.10248 (2025), https://arxiv.org/abs/2502.10248v3
  25. [25]
    MiniMax: MiniMax H3. Official repository documentation (2026), https://github.com/MiniMax-AI/MiniMax-H3/blob/d21241f0a4b3acbb34c97dae47fa417b7065e438/README.md, accessed 7 October 2026
  26. [26]
    Narayanan, D., Shoeybi, M., Casper, J., et al.: Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM. arXiv:2104.04473 (2021), https://arxiv.org/abs/2104.04473v5
  27. [27]
    Peebles, W., Xie, S.: Scalable Diffusion Models with Transformers. arXiv:2212.09748 (2022), https://arxiv.org/abs/2212.09748v2
  28. [28]
    Peng, B., et al.: YaRN: Efficient context window extension of large language models. arXiv:2309.00071 (2023), https://arxiv.org/abs/2309.00071
  29. [29]
    Polyak, A., Zohar, A., Brown, A., et al.: Movie Gen: A cast of media foundation models. arXiv:2410.13720 (2024), https://arxiv.org/abs/2410.13720v2
  30. [30]
    Rafailov, R., et al.: Direct preference optimization: Your language model is secretly a reward model. arXiv:2305.18290 (2023), https://arxiv.org/abs/2305.18290
  31. [31]
    Rombach, R., Blattmann, A., Lorenz, D., et al.: High-Resolution Image Synthesis with Latent Diffusion Models. arXiv:2112.10752 (2021), https://arxiv.org/abs/2112.10752v2
  32. [32]
    SageAttention Contributors: SageAttention: Official implementation. https://github.com/thu-ml/SageAttention/tree/d1a57a546c3d395b1ffcbeecc66d81db76f3b4b5, accessed 1 October 2026; family reference, not the confirmed Vimoo kernel revision
  33. [33]
    Salimans, T., Ho, J.: Progressive Distillation for Fast Sampling of Diffusion Models. arXiv:2202.00512 (2022), https://arxiv.org/abs/2202.00512v2
  34. [34]
    Shoeybi, M., et al.: Megatron-LM: Training multi-billion parameter language models using model parallelism. arXiv:1909.08053 (2019), https://arxiv.org/abs/1909.08053
  35. [35]
    Song, Y., Dhariwal, P., Chen, M., et al.: Consistency Models. arXiv:2303.01469 (2023), https://arxiv.org/abs/2303.01469v2
  36. [36]
    Su, J., et al.: RoFormer: Enhanced transformer with rotary position embedding. arXiv:2104.09864 (2021), https://arxiv.org/abs/2104.09864
  37. [37]
    Team Seedance, et al.: Seedance 2.0: Advancing video generation for world complexity. arXiv:2604.14148 (2026), https://arxiv.org/abs/2604.14148v1, model Card
  38. [38]
    Team Wan, et al.: Wan: Open and Advanced Large-Scale Video Generative Models. arXiv:2503.20314 (2025), https://arxiv.org/abs/2503.20314v2
  39. [39]
    Vaswani, A., Shazeer, N., Parmar, N., et al.: Attention Is All You Need. arXiv:1706.03762 (2017), https://arxiv.org/abs/1706.03762v7
  40. [40]
    Wallace, B., Dang, M., Rafailov, R., et al.: Diffusion Model Alignment Using Direct Preference Optimization. arXiv:2311.12908 (2023), https://arxiv.org/abs/2311.12908v1
  41. [41]
    Wan-Video: Wan2.2: Official repository and VAE documentation. https://github.com/Wan-Video/Wan2.2, accessed 22 September 2026; exact model revision to be confirmed
  42. [42]
    Wang, J., Lin, S., Lin, Z., Ren, Y., Wei, M., Yue, Z., Zhou, S., Chen, H., Zhao, Y., Yang, C., Xiao, X., Loy, C.C., Jiang, L.: SeedVR2: One-step video restoration via diffusion adversarial post-training. In: International Conference on Learning Representations (2026), https://arxiv.org/abs/2506.05301v2
  43. [43]
    Wang, J., Lin, Z., Wei, M., Zhao, Y., Yang, C., Xiao, F., Loy, C.C., Jiang, L.: SeedVR: Seeding infinity in diffusion transformer towards generic video restoration. In: Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (2025), https://arxiv.org/abs/2501.01320v4
  44. [44]
    Wu, B., Zou, C., Li, C., et al.: HunyuanVideo 1.5 Technical Report. arXiv:2511.18870 (2025), https://arxiv.org/abs/2511.18870v2
  45. [45]
    Xue, L., Barua, A., Constant, N., et al.: ByT5: Towards a token-free future with pre-trained byte-to-byte models. arXiv:2105.13626 (2021), https://arxiv.org/abs/2105.13626v3
  46. [46]
    Yang, Z., Teng, J., Zheng, W., et al.: CogVideoX: Text-to-Video Diffusion Models with An Expert Transformer. arXiv:2408.06072 (2024), https://arxiv.org/abs/2408.06072v3
  47. [47]
    Yin, T., Gharbi, M., Park, T., Zhang, R., Shechtman, E., Durand, F., Freeman, W.T.: Improved distribution matching distillation for fast image synthesis. In: Advances in Neural Information Processing Systems. vol. 37 (2024), https://arxiv.org/abs/2405.14867v2
  48. [48]
    Yin, T., Gharbi, M., Zhang, R., Shechtman, E., Durand, F., Freeman, W.T., Park, T.: One-step diffusion with distribution matching distillation. In: Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (2024), https://arxiv.org/abs/2311.18828v4
  49. [49]
    Yin, T., Zhang, Q., Zhang, R., Freeman, W.T., Durand, F., Shechtman, E., Huang, X.: From slow bidirectional to fast autoregressive video diffusion models. In: Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (2025), https://arxiv.org/abs/2412.07772v4
  50. [50]
    Zhai, X., et al.: Sigmoid loss for language image pre-training. In: Proceedings of the IEEE/CVF International Conference on Computer Vision (2023), https://arxiv.org/abs/2303.15343
  51. [51]
    Zhang, B., Sennrich, R.: Root Mean Square Layer Normalization. arXiv:1910.07467 (2019), https://arxiv.org/abs/1910.07467v1
  52. [52]
    Zhang, J., Wei, J., Huang, H., et al.: SageAttention: Accurate 8-Bit Attention for Plug-and-play Inference Acceleration. arXiv:2410.02367 (2024), https://arxiv.org/abs/2410.02367v9
  53. [53]
    Zheng, D., Huang, Z., Liu, H., et al.: VBench-2.0: Advancing Video Generation Benchmark Suite for Intrinsic Faithfulness. arXiv:2503.21755 (2025), https://arxiv.org/abs/2503.21755v2