Introduction

The 4-bit H3 stack just got a real tune-up. FastH3-QAD-v2 from the FastVideo team at Hao AI Lab (UC San Diego) is a retrained NVFP4 version of their 8-step MiniMax H3 distill, the open model that makes video with synchronized audio. It landed on October 19 alongside two new NVFP4 VAE decoders and direct loading for community H3 LoRAs.

It's open weights under the MiniMax H3 community license, and you can run it today through the FastVideo Python library on one Blackwell GPU (RTX 5090, RTX PRO 6000) or a DGX Spark. The headline number: a 5-second 480p clip with audio now takes about 12.6 seconds end to end on a single RTX 5090.

If you caught our FastH3 V2 and Trim consumer-GPU story, think of this as the same model with better 4-bit manners and a much quicker last step.

What Shipped

  • Model: FastH3-QAD-v2, an 8-step video + audio checkpoint with NVFP4 weights
  • Decoders: FastH3 NVFP4 VAE Decoder in two tiers, quality (36 layers) and fast (8 layers)
  • LoRAs: community MiniMax H3 LoRAs now load directly in FastVideo, including on 4-bit models
  • Vendor: FastVideo / Hao AI Lab at UC San Diego, built on MiniMax H3
  • Modality: text-to-video with synchronized audio
  • Open vs closed: open weights on Hugging Face (MiniMax H3 community license)
  • Where to run today: FastVideo on RTX 5090, RTX PRO 6000, DGX Spark, or B200/GB200
  • Concrete fact: the whole text-to-video stack now weighs about 30 GiB instead of 118.3 GiB in BF16, roughly 3.9x smaller

Why QAD Beats Plain 4-Bit

FastH3 V2 was quantized the quick way: calibrate scales on 1,000 prompts, then round every weight to 4 bits. That works, but rounding error sneaks into the output.

Quantization-aware distillation (QAD) goes further. The full-precision V2 model acts as the teacher, and the 4-bit student trains through the rounding on all 350 quantized linear layers, so its weights learn to live with 4-bit math. At each of the eight sampling steps, the student sees the teacher's input and learns to match its output. A quarter of the samples run on the student's own path, so it learns to recover from its own small slips.

The recipe is surprisingly light: 3,000 text prompts, 300 steps, about five hours on two GB200 nodes. The team kept the sparse-attention gates and norms in BF16 on purpose, because changing those would change which video tiles the model looks at, not just the arithmetic.

The result, measured as error against full-precision V2 on 30 held-out prompts (lower is better):

  • Per step, video + audio: 0.431 down to 0.351 (about 19% lower)
  • Video: 0.471 down to 0.382 (about 19% lower)
  • Audio: 0.391 down to 0.319 (about 18% lower)
  • Final video after all 8 steps: 0.817 down to 0.713 (about 13% lower)

Same memory, same file layout, so it's a drop-in swap for V2 users. These are the team's own measurements, not an independent benchmark.

The NVFP4 VAE Decoders

Once the transformer and text encoder went 4-bit, the VAE decoder became the slow part. On a DGX Spark, the INT8 lightweight VAE took 43 seconds to decode a 5-second 480p clip, a third of total time. Both new decoders are distilled from the original 36-layer H3 decoder and trained on FastH3's own outputs:

  • Quality tier (36 layers): 1.29 GiB instead of 4.5 GiB, within about 0.1 dB PSNR of the original. In blind side-by-side votes against the original decoder it scored 2 wins, 2 losses and 7 ties.
  • Fast tier (8 layers): 0.31 GiB and about 15x faster than the original, at some quality cost.
  • On one DGX Spark: decode drops from 43 seconds to 1.6 seconds.

On LightVAE's own test protocol, the team reports the 36-layer decoder beats LightVAE-Lite by about 1.9 dB, and the 8-layer one matches Lite's PSNR while running about 5.4x faster and being about 5x smaller.

One catch: the NVFP4 decoders need FP4 tensor cores, so they only run on Blackwell (RTX 50 series, RTX PRO 6000, DGX Spark, B200/GB200). On Ada, Hopper or older cards, stick with the original H3 decoder.

The Speed Numbers

End to end on a warm server, prompt to finished MP4 with audio, for a 5-second 832x480 clip (8-layer decoder / 36-layer decoder):

  • RTX 5090: 12.6 s / 14.1 s
  • One DGX Spark: 52.7 s / 58.1 s, down from 141 s
  • Two DGX Sparks: 30.7 s / 33.6 s

Run It With Your LoRAs

This is the fun part for Comfy folks. LoRAs trained for base H3 in ComfyUI, fal, ai-toolkit or musubi-tuner layouts now load straight into FastVideo. On 4-bit models, the packed weights stay untouched and each LoRA runs as a small BF16 side branch next to its layer. Strength 0 gives you the base model exactly, and a LoRA that doesn't match the model fails loudly with a list of what missed, instead of quietly doing nothing.

Install FastVideo with uv (swap cu126 for cu130 on CUDA 13; DGX Spark needs the from-source install in the FastVideo docs):

UV_TORCH_BACKEND=cu126 uv pip install fastvideo

LoRA loading merged into FastVideo main on October 19, so if your installed release doesn't have it yet, install from a fresh clone of the repo. Then here's the team's example, loading a community 360-orbit camera LoRA on top of QAD-v2:

from fastvideo import VideoGenerator
from fastvideo.api import ComponentConfig, GeneratorConfig, PipelineSelection

generator = VideoGenerator.from_config(
    GeneratorConfig(
        model_path="FastVideo/FastH3-QAD-v2",
        pipeline=PipelineSelection(
            components=ComponentConfig(
                lora_path="pablodawson/MiniMax-H3-360-Orbit-LoRA",
                lora_strength=0.8,
            ),
        ),
    )
)

On a machine with less than 64 GB of system RAM, point FastVideo at the precomputed timestep table so it can skip 26 GB of AdaLN weights:

import os
from huggingface_hub import hf_hub_download

os.environ["FASTVIDEO_H3_ADALN_TABLE"] = hf_hub_download(
    "FastVideo/FastH3-QAD-v2", "transformer/adaln_tables.pt")

To swap in a 4-bit decoder, download one tier and set FASTVIDEO_H3_VAE_NVFP4_DECODER to the file path:

hf download FastVideo/FastH3-NVFP4-VAE-Decoder quality-36L/decoder-nvfp4.safetensors --local-dir fasth3-nvfp4-vae
export FASTVIDEO_H3_VAE_NVFP4_DECODER=$PWD/fasth3-nvfp4-vae/quality-36L/decoder-nvfp4.safetensors

A few honest notes from the team: most community LoRAs were trained for base H3's 50-step schedule, so style and motion LoRAs usually carry over but the best strength may differ, and you don't need turbo LoRAs at all. LoRAs don't work on FastH3 Trim yet, since Trim removes transformer blocks.

What's Next: FastH3 OmniRef

The team says this release is the foundation for FastH3 OmniRef, due "tomorrow" in their October 19 post: the general reference-to-video-and-audio model plus training code in BF16, and a consumer release built on this QAD recipe and the new decoders. That's the open version of the FastH3-Omni preview we covered last week.

The inference code is already in: FastVideo main merged OmniRef support for RTX 5090, RTX PRO 6000, DGX Spark and RTX 4090 on October 19. The OmniRef checkpoint itself wasn't public on Hugging Face when we checked at 10:55 MYT on October 20, so treat it as coming soon.

Original Source

https://haoailab.com/blogs/fasth3-v21/

Conclusion

FastH3-QAD-v2 is the kind of update that makes local video feel less like a stunt and more like a tool: about a fifth less error at the same size, a decoder that turns a 43-second wait into under two, and your favorite H3 LoRAs riding along on 4-bit weights. Grab the checkpoint, try the 8-layer decoder for drafts and the 36-layer one for finals, and keep an eye out for OmniRef.

Want to play with MiniMax H3 without a Blackwell card? Try this on Gen → https://artrealmai.com/gen?utm_source=magazine&utm_campaign=gen&utm_content=fasth3-qad-v2-nvfp4-vae-decoders-community-loras

—Aurelia ♡