HyperFlow H3 Flash: 14B Open Weights for Joint Video and Stereo Audio

HyperFlow H3 Flash is an open-weight image-text-to-video stack that outputs synchronized stereo audio in the same forward pass — a niche MiniMax-H3 cousin compressed to ~14B parameters and four to eight diffusion steps without classifier-free guidance. Video Rebirth published weights on Hugging Face with GGUF, INT8 convrot, ComfyUI templates, and a hyperflow-h3-flash Python CLI timed on RTX 5090 through B200 clusters.

If you follow MiniMax H3 image open weights for stills, this is the joint AV lane: same licensing family, different partition layout (fl2va vs ref2va).

TL;DR

What the Hub repo actually ships

The model card is explicit: this repo holds only compressed transformers (fl2va_int8_convrot, ref2va_int8_convrot, GGUF folders). Each runtime downloads:

• Text encoder and tokenizers from MiniMaxAI/MiniMax-H3 or Qwen3-VL-32B-FP8 when you pass --text-encoder-precision fp8
• Video and audio VAEs from Comfy-Org/MiniMax-H3 for ComfyUI and stable-diffusion.cpp

The Python installer never pulls the 62 GB base MiniMax-H3 transformer — only companions — which is why a 14B distill can feel like a full pipeline on a workstation.

Task matrix (from the card)

ref2va is the power feature: name references as <Picture i>, <Video i>, <Audio i> in prompt order. Limits: 9 images, 3 videos, 3 audio clips, 12 total. GGUF routes support image refs only; mixed video/audio refs need the Python package.

Weight formats and when to use each

The card's decision rule is practical:

• ComfyUI on 24 GB+ RTX → INT8 *_comfyui safetensors + Triton-friendly PyTorch (CUDA 13+ or --enable-triton-backend)
• Smaller VRAM or cpp/Studio → GGUF (Q4_K_M recommended)
• Data-center batch → hyperflow-h3-flash INT8 convrot package

Territory warning: accepting weights means the MiniMax H3 Community License — worldwide except EU, UK, South Korea, and USA unless MiniMax authorizes you. Builders in restricted regions need legal review before downloading.

How to run: CLI quick start

Install from GitHub per the card:

pip install git+https://github.com/Video-Rebirth/hyperflow-h3-flash

Text-to-video-audio:

hyperflow-h3-flash --prompt "A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window." \
  --output ramen.mp4

Key flags:

The card embeds a load_pipeline Python example exporting MP4 with video + audio tracks through encode_video.

ComfyUI and GGUF paths

For GGUF on consumer GPUs:

1. Install ComfyUI-GGUF and ComfyUI-HyperFlow-Flash custom nodes
2. Place minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf under models/diffusion_models/
3. Fetch nvfp4_awq text encoder (~15.7 GB) from Comfy-Org
4. On 16–32 GB RAM PCs, launch with python main.py --fast-disk
5. Load templates from Workflow → Browse Templates → ComfyUI-HyperFlow-Flash

For INT8 on 24 GB+, skip GGUF nodes; use *_int8 workflows and HyperFlow Loader — stock Comfy loaders do not understand two-time (t, r) conditioning or factorized linears.

Three doorways opening into one hall, illustrating HyperFlow paths from text, keyframes, or references into one video pipeline

Measured 5.2 s / 6 steps on RTX 5090 (ComfyUI INT8): 83 s total in the card's table; 4090 around 152 s. GGUF Q4_K_M lands near 99 s on 5090 with fast-disk tricks — INT8 wins 5–15% in same-pod tests cited on the card.

Filmstrip frames sharing the same leaf motif, illustrating temporal consistency targets for few-step HyperFlow video clips

Benchmarks worth citing (and verifying)

All timings are end-to-end (encode → 6-step transformer → VAE decode) at 1344×768.

Consumer (card table):

• RTX PRO 6000 96GB INT8 ComfyUI: 53 s / 333 s (5.2s / 15s)
• RTX 5090 32GB: 83 s / 518 s INT8 ComfyUI
• RTX 4090 24GB: 152 s / 747 s

Data-center Python INT8:

• 1× H200: 36 s (5.2s clip)
• 4× B200: 8.7 s (5.2s clip)

Partner NVIDIA SOL-H3 claims real-time HyperFlow on 4× B-series — a separate stack from the open Python timings.

Treat every number as vendor table data until you replicate on your drivers; video stacks swing wildly with Triton, text encoder precision, and page-cache tricks.

Mechanism: why 6 steps can work

The README explains three compression ideas:

1. Structural pruning — drops specific transformer blocks; factors large linear layers
2. Rotated W8A8 INT8 (convrot) — Hadamard-rotated INT8 linears with kernel fallbacks
3. Two-time (t, r) conditioning — each token sees noise level t and step endpoint r, enabling CFG-free few-step schedules

Shared sigma grids (video_shift=12, audio_shift=3) define the 4/6/8 step ladders printed in the card — reuse them when porting to custom schedulers.

Comparison anchors on explainx.ai

For agent filmmakers, pair outputs with ViMax agentic video orchestration only if your license territory allows MiniMax derivatives.

Prompting and limitations

• Single positive prompt — no negative prompt (CFG fixed at 1.0)
• Describe subject, motion, setting, camera, sound together
• ref2va requires structured <Picture> / <Video> / <Audio> tags
• Failure modes inherit MiniMax-H3 biases and language limits listed on the upstream model
• Not clinical, not broadcast-safe by default — run your own moderation

What developers asked on Hugging Face (traction context)

The model shows ~189 likes on Hub trending lists — modest, but the card's depth (Comfy + cpp + Hopper kernels) is unusually complete for a community distill. Watch:

• License territory threads for US/EU labs
• 16 GB GPU claims marked not measured yet
• Unsloth Studio integration path for one-click local trials

Troubleshooting paths the model card documents

The README encodes failure modes teams hit when stitching companions:

ComfyUI on 16 GB system RAM PCs — start with python main.py --fast-disk so GGUF weights stream from the page cache instead of pinning everything in anonymous RAM. The card says 12 GiB left to ComfyUI succeeded on RTX 5090 INT8 without fast-disk, but margins are thin.

Triton vs PyTorch INT8 fallback — ComfyUI's default INT8 path can run ~50% slower without --enable-triton-backend or a CUDA 13+ PyTorch build. If your container image ships older CUDA, expect regression versus the cited 83 s 5090 numbers.

15 s clips on 24 GB ref2va — pass --block-chunk 16384 in the Python CLI when mixing image + video + audio references; the card lists 630 s on 4090 without chunking versus 503 s with tuning for 5.2 s mixed inputs.

Text encoder precision — fp8 requires the [fp8] extra; it saves ~22 GiB system RAM when offloading but changes numerics slightly. Benchmark one golden prompt in bf16 before batching client work.

stable-diffusion.cpp — apply the pinned patch commit in the card; upstream drift breaks two-time scheduling. Treat cpp integration as maintainer-supported rather than casual git pull.

Legal and geographic constraints (read before CI)

The MiniMax H3 Community License is not a permissive OSI license. Besides territory carve-outs, it binds Model Derivative redistribution rules to MiniMax's acceptable-use policy. If you run a SaaS API wrapping HyperFlow outputs:

• Confirm whether your counsel treats fine-tuned adapters as derivatives.
• Log end-user territory — US/EU/UK/KR users may be out of scope without MiniMax authorization.
• Do not assume Hugging Face's hosting grants you rights your contracts lack.

Video Rebirth's card repeats that the repo is not an official MiniMax product — support channels are GitHub issues and community Discord, not MiniMax enterprise SLAs.

Where HyperFlow fits the November 2026 video stack

Closed APIs still lead on latency SLAs and rights-managed training. Open stacks win when teams need on-prem review, custom ref2va branding, or mixed audio+video conditioning without per-second cloud tariffs.

Compared with official MiniMax-H3 full transformers, HyperFlow trades parameter count for step count — you accept CFG=1 schedules and possible detail loss on long camera moves in exchange for 9 GB GGUF footprints. Compared with image-only open weights like MiniMax H3 image, HyperFlow is the motion+audio branch.

Agency pipelines might chain: Screen Test-style character bible (future Adobe) → HyperFlow ref2va for animatics → final grade in Resolve. None of that is turnkey; it is a lego set for teams already comfortable downloading 15 GB text encoders.

Practical checklist before production

1. Confirm MiniMax license coverage for your entity and geography
2. Pin text encoder revision (nvfp4_awq vs bf16) — changes RAM cliffs
3. Log seed, steps, frame count — reproducibility still varies by kernel
4. Store companion VAE hashes beside transformer quants for audit
5. Compare against closed APIs on the same prompt for lip-sync and motion metrics

Related on explainx.ai

• MiniMax H3 open image weights
• Apex few-step video conditioning research
• Fish Audio Live 3 duplex voice agents
• Adobe–Google generative video partnerships
• WorldFoundry world-model benchmarks
• ViMax agentic video generation guide

Quant sizes, benchmark tables, and license URLs match the Hugging Face model card as of November 11, 2026.