Video DeltaNet: Hybrid Attention to Speed Up Video Models with Near-Lossless Quality

[Blog] [🤗 HuggingFace] [License]

We release VDN-Minimax-H3 (VDN-H3), a hybrid-attention model that generates video faster than it plays, powered by MiniMax H3. It offers these key features:

• Fast inference: On 8 B200 GPUs, VDN-H3 generates a 14.4-second clip in 11.23 seconds using 8 denoising steps.
• Hybrid Architecture: We propose a hybrid-attention architecture: one frame-wise linear attention branch that is highly efficient, and a softmax branch that maintains the backbone's visual quality and consistency.
• Plug-and-Play: The checkpoint adds a separate linear attention branch and two small LoRA adapters that can be merged into the backbone during inference without touching the backbone weights.
• Fully open-source: We don't just open-source the weights. The optimized inference stack and its corresponding training code are released together.

We present some samples of generated videos here:

Before you begin, please read the license before downloading or running VDN-H3.

1. Clone the VDN-H3 repository from GitHub.

git clone https://github.com/OpenVDN/vdn-minimax-h3.git
cd vdn-minimax-h3

2. Create the environment. We recommend PyTorch 2.13 (torch.__version__ = 2.13.0+cu129) and installing FlashAttention 4, since our code requires FlexAttention's Flash backend.

conda create -n vdn python=3.12 -y
conda activate vdn
pip install uv

uv pip install torch==2.13.0 --index-url https://download.pytorch.org/whl/cu129

3. Install the other packages shown in pyproject.toml, flash-attn-4 included (--prerelease=allow is needed for its pre-release nvidia-cutlass-dsl dependency).

uv pip install --prerelease=allow -e .

4. Install the patched Diffusers. The setup script handles everything:

bash scripts/setup_diffusers.sh

Download everything (about 82 GB) into ckpts/ using

hf download OpenVDN/vdn-minimax-h3 --local-dir ckpts

The layout will look like

ckpts/
  h3-base/             the released MiniMax H3: transformer, video and audio VAEs, schedulers · 72 GB
  stage-b-step-2000/   VDN-H3-50-step: linear_branch/ + adapters/default/ LoRA · 4.3 GB
  stage-dmd-step-250/  VDN-H3-8-step: the above + adapters/turbo/ · 5.1 GB

The simplest way to start is by running the model on a single GPU:

bash scripts/inference/8nfe_tuned_fp8.sh

Note that the first run needs to compile all of the kernels, which might take several minutes. Later runs can reuse the cache.

We provide three examples and encode them using the Qwen3-VL-32B VLM. For your own prompt, you should first encode it using the VLM, then render it through the main diffusion model:

python src/inference/encode_prompt.py --prompt "..." --out prompts/mine.pt

python src/inference/infer.py \
  --config configs/inference/8nfe_tuned_fp8.yaml \
  checkpoint=ckpts/stage-dmd-step-250 \
  render.prompt_file=prompts/mine.pt \
  render.out=results/mine.mp4

We strongly recommend rewriting it first using H3-Context-IR or the official prompt-writing skills before encoding it. This can greatly improve the generated video quality.

We support both single-GPU and multi-GPU inference for the released model. Single-GPU scripts auto-detect the best kernels for your GPU. Multi-GPU scripts vary for different hardware (H200, B200) to achieve the best performance.

bash scripts/inference/8nfe_tuned_fp8.sh                # one GPU
bash scripts/inference/8nfe_tuned_fp8_ulysses_h200.sh   # eight H200s, one node
bash scripts/inference/8nfe_tuned_fp8_ulysses_b200.sh   # eight B200s, one node

We report steady-state denoising speed on the 768p, 14.4-second video generation workload for the released model using our inference pipeline on H200s and B200s:

H200:

B200:

We exclude model loading, warm-up, VAE decoding, and MP4 encoding. For a live setup, we recommend running the text prompt rewriter, VAE decoding, and MP4 conversion on separate machines, so the eight GPUs only denoise.

VDN-H3 is trained in three stages based on the frozen dense model, each starting from the previous stage's final checkpoint. We additionally include a DMD training stage to align with the community few-step distillation LoRA. The training scripts are located in src/training/ and scripts/training/, and all training configurations can be found under configs/training/.

To reproduce the training process, run:

bash scripts/training/stage_a1.sh       data.index_file=/path/to/video_index.jsonl
bash scripts/training/stage_a2.sh       data.index_file=/path/to/video_index.jsonl
bash scripts/training/stage_b.sh        data.index_file=/path/to/video_index.jsonl
bash scripts/training/stage_dmd_vdn.sh  data.index_file=/path/to/video_index.jsonl

The trainers read pre-encoded video latents, audio latents, and text latents, following the H3 standard pipeline. Captions should be written in the same format inference expects.

The preprocessed data should be placed as follows, with a video_index.jsonl carrying the metadata:

<root>/
├── video_index.jsonl       one JSON row per clip, carrying its "latent_path"
├── video/
│   ├── 00000.pt            (24, 102, 48, 84) bf16 — video VAE, normalized space
│   └── ...
├── audio/
│   ├── 00000.pt            (2, 32, 575) bf16 — audio VAE, stereo, 40 latents/s
│   └── ...
└── text/
    ├── 00000.pt            {"prompt_embeds": (L, 5120) bf16,
    │                        "text_token_tags": (L,) int64}
    └── ...

data.index_file names the jsonl. Only latent_path is read from a row; the audio and text sidecars are found by path arithmetic — same file name, sibling directory — so latent_path must end in video/<name>.pt. The reader is src/training/dataset_h3_latents.py.

Stage-DMD is data-free, only requiring the text rows. Its turbo LoRA adapter is initialized from larryvrh/MiniMax-H3-Turbo-Lora, which the config expects in ckpts/external/:

hf download larryvrh/MiniMax-H3-Turbo-Lora \
  minimax_h3_turbo_v4_step600_ema.safetensors --local-dir ckpts/external

VDN-H3 is built on MiniMax H3 and starts from its released transformer weights. We also thank Diffusers, FlashAttention, and Triton, on which the optimized inference path is built.

@misc{xi2026videodeltanet,
  title  = {VideoDeltaNet on MiniMax H3},
  author = {Haocheng Xi and Yiming Xie and Hexu Zhao and Yiwen Zhang and Michael Liu and Thomas Creavin and Kurt Keutzer and Xiuyu Li and Zhaoyang Lv and Chenfeng Xu and Haiwen Feng},
  year   = {2026},
  url    = {https://openvdn.github.io/}
}

VDN-Minimax-H3 · Independent architecture study · 2026

This repository contains the VDN-H3 training and inference code, which is licensed under the Apache License, Version 2.0. Copyright 2026 the VDN authors.

The model weights are not in this repository and are not covered by that license. VDN-H3 is a derivative of MiniMax H3, and its weights are distributed separately at huggingface.co/OpenVDN/vdn-minimax-h3 under the MiniMax H3 Community License Agreement.