Video Rebirth's HyperFlow Cuts MiniMax-H3 to 14B; NVIDIA Runs It Real-Time

TL;DR

HyperFlow H3 Flash, released November 6 by AI video company Video Rebirth, is a compressed rewrite of MiniMax-H3, the open-weight model that generates video and synchronized stereo audio in a single pass. Pruning and low-rank refactoring take the roughly 31B-parameter transformer down to 13.7B, Hadamard-rotated INT8 shrinks the runtime, and a two-time conditioning trick cuts sampling to 4, 6, or 8 steps with no classifier-free guidance. A 5.2-second clip renders in 92 seconds on one RTX 5090, and NVIDIA's SOL-H3 runner does the same clip in 3.4 seconds on four GB200s. The catch: the weights ship under MiniMax's community license, which does not cover the US, EU, UK, or South Korea.

What shipped

MiniMax-H3 landed in August with open weights and a genuine party trick: one model producing video and a 32 kHz stereo soundtrack together. The bill was a ~31B transformer and a long sampling trajectory. The local story at launch was a 12 GB RTX 3060 grinding out five seconds of footage in about nine minutes.

Flash attacks the size and the step count at the same time. The release contains two compressed transformers: fl2va at 13.7B parameters for text-to-video-and-audio and keyframe tasks, and ref2va at 13.9B for reference-driven generation with up to 12 inputs, specifically 9 images, 3 videos, and 3 audio clips. Output runs 5.2 to 15 seconds at 24 fps, 1344x768 by default, soundtrack attached.

Four ways to run it: a pip-installable CLI and Python API over diffusers, ComfyUI custom nodes with GGUF checkpoints loaded through ComfyUI-GGUF, a patch that teaches stable-diffusion.cpp the new conditioning, and Unsloth Studio, whose MiniMax-H3 GGUF layout the release follows. Your first run pulls roughly 90 GB of companion files, the text encoder and VAEs, but never the 62 GB base transformer: Flash ships only the two small diffusion transformers and borrows everything else from upstream.

Three cuts, stacked

Cut one, structure. fl2va drops 3 of 50 transformer blocks (6, 21, and 22) and factors 102 linear layers into low-rank pairs; ref2va drops 1 block and factors 114. That surgery alone takes ~31B to under 14B.

Cut two, precision. 180 linear layers go to W8A8 INT8 behind a block-diagonal Hadamard rotation. INT8 gives you 256 levels, and diffusion transformers keep a few channels with outsized values that would eat the whole range. The rotation fixes that: rotate the frame first and the outliers smear across every dimension. Salt the whole dish evenly instead of tasting one clump.

Cut three, steps. Every token receives two clocks, the current noise level t and the endpoint r of the current step. Each pass knows where it is and where the schedule finishes, so 4, 6, or 8 steps suffice with CFG off, which also removes the second forward pass that guidance normally costs. Picture a relay runner who knows both her split and the finish time the team committed to.

The rotated-INT8 idea was pioneered on MiniMax-H3 by WAS's Singularity v2 pruned model, which the team credits. Their contribution is finishing the job: INT8 kernels dispatched per architecture from Ampere through B300 (with a BF16 fallback on B300, where INT8 tensor throughput is throttled), plus the two-time conditioning that makes few-step sampling hold together. There is also a sibling 8-step LoRA for the full-size transformer if you want fewer steps without the surgery.

The numbers people will quote

All timings are end-to-end at 1344x768 and 6 steps: text encoding, six transformer passes, and both VAE decodes. One H200 produces a 5.2-second clip in 36 seconds, four H200s in 12.6, four B200s in 8.7. A 15-second clip at 1920x1088 takes 220 seconds across four H200s. On a desk, the INT8 path lands 5.2 seconds in 92 seconds on an RTX 5090, 130 on a 4090, 266 on a 3090, and a 15-second clip in 551 seconds on the 5090.

The GGUF path matters more for homelab budgets. Q4_K_M is 9.1 GB and runs on 24 GB and 32 GB GPUs inside PCs with 16 GB of system RAM, streaming unresident weights from the page cache. Q3_K_M gets you 7.2 GB. The INT8 numbers assume 69 to 91 GB of RAM for offloading; a 5090 box with 16 GB of RAM still manages 130 seconds through GGUF with the fast-disk flag. Joint video and audio, from a 9 GB file, on hardware you probably already own.

Then NVIDIA arrived. SOL-H3 lives in the NVlabs Sana repository as a day-0 runner for Flash: block-sparse attention through cuDNN, INT8 QKV transport, and a table from November 5 measured against weights pinned by SHA-256. A 5-second text-to-video clip takes 3.4 seconds on four GB200s and 1.9 on eight. A 93-star repo getting a validated runner from NVIDIA's research org does not happen most release days.

Read the license before you queue the download

Split the release in two before you call it open. The repository code is Apache 2.0, with the ComfyUI nodes under GPL-3.0 and the stable-diffusion.cpp patch under MIT. The weights are a Model Derivative of MiniMax-H3 under the MiniMax H3 Community License Agreement: no license for the EU, UK, South Korea, or the US without MiniMax's prior authorization, plus an Acceptable Use Policy, and the model card is explicit that this is not an official MiniMax product. Nothing stops the download. The license changes what you may do afterward, which is the standard open-weights experience in 2026.

What to steal

• Multiply independent cuts. Pruning, low-rank factoring, rotated INT8, and fewer steps each attacked a different cost, and the product of the savings is the story. A single-axis optimization would have produced a footnote.
• Ship only the delta. Flash distributes two small transformers and reuses the upstream text encoder and VAEs at load time; the 62 GB original is never fetched. If you publish a derivative model, this is the pattern.
• Pin provenance with digests. NVIDIA validated byte-identical shards by SHA-256 before publishing benchmarks. It costs nothing, and it is the reason third-party numbers can be trusted at all.
• Promise bitwise reproducibility. Same seed, GPU architecture, GPU count, and attention backend give identical clips, and multi-GPU parallelism preserves it. Anyone regression-testing a creative pipeline needs exactly this.
• Read the weights' license, not the repo's. Apache 2.0 on the code says nothing about what the checkpoint permits, and territory exclusions turn a fun demo into a legal question the moment money is involved.

Caveats

• There is no published quality comparison between Flash and the full-size MiniMax-H3, or between quant levels. Show HN commenters asked immediately; the showcase page has samples, but samples are marketing. The compression ratios are verified, the quality cost is not.
• NVIDIA's own validation document marks its GPU numerics gate against the released code as in progress. The timing tables are real; the equivalence proof is not finished.
• The license excludes the US, EU, UK, and South Korea without MiniMax authorization. For many readers this is the whole story.
• 16 GB GPUs are unmeasured, and the fastest INT8 path wants 69 to 91 GB of system RAM. GGUF with fast-disk is the realistic path for ordinary PCs.
• Timings other than NVIDIA's GB200 table are maker-reported. The SOL-H3 numbers come from a fixed protocol: one prompt, seed 0, median of two warm requests.
• GGUF ref2va accepts image references only; video and audio references require the Python package.

Key Takeaways

• Video Rebirth released HyperFlow H3 Flash on November 6: MiniMax-H3's roughly 31B video-and-audio transformer compressed to 13.7B (fl2va) and 13.9B (ref2va) via block pruning, low-rank factorization, and Hadamard-rotated W8A8 INT8.
• Two-time (t, r) conditioning enables 4, 6, or 8 sampling steps without classifier-free guidance; 6 is the default, producing 24 fps video at 1344x768 with a 32 kHz stereo soundtrack.
• A 5.2-second clip takes 92 seconds on one RTX 5090, 36 on one H200, and 8.7 on four B200s; the Q4_K_M GGUF is 9.1 GB and runs on 24 GB GPUs in PCs with 16 GB of RAM.
• NVIDIA's SOL-H3 runner, day-0 in the NVlabs Sana repository, generates a 5-second clip in 3.4 seconds on four GB200s, measured November 5 against SHA-256-pinned weights.
• Repo code is Apache 2.0, but the weights follow the MiniMax H3 Community License Agreement: not licensed in the US, EU, UK, or South Korea without MiniMax's authorization.
• Runtimes cover ComfyUI, stable-diffusion.cpp, Unsloth Studio, and a diffusers-based CLI; first run downloads about 90 GB of companions and never the 62 GB base transformer.

Sources: Video Rebirth, HyperFlow H3 Flash, Hugging Face model card, NVIDIA SOL-H3, NVlabs Sana, Show HN thread, Video Rebirth showcase