HyperFlow H3 Flash shrinks MiniMax-H3's video-with-audio model to 14B parameters
Startup Video Rebirth has cut MiniMax-H3, a model that generates video and audio together, from about 31 billion to just under 14 billion parameters. It now needs only 4 to 8 sampling steps and runs as a GGUF on 24 GB gaming GPUs. One user test even got it running on 16 GB. There's a catch if you're in Europe: the license doesn't cover use in the EU unless MiniMax gives you permission.
What's going on
Video Rebirth has released HyperFlow H3 Flash, a much smaller and faster version of the MiniMax-H3 video model. Like the original, it generates video and matching stereo audio in a single pass. You can start from a text prompt, a start frame, a start and end frame, or up to twelve references (images, videos, audio clips). The weights are freely available on Hugging Face at VideoRebirthAI/hyperflow-h3-flash. The release also includes a Python package, dedicated ComfyUI nodes and guides for Unsloth Studio and stable-diffusion.cpp. The project was launched as a "Show HN" on Hacker News.
The headline: MiniMax-H3's transformer had roughly 31 billion parameters. The new version has 13.7 billion (fl2va variant) or 13.9 billion (ref2va), less than half. Instead of many sampling steps, 4, 6 (the default) or 8 are enough.
What the model generates
- Length: 5.2 to 15 seconds of video at 24 frames per second
- Resolution: 1344×768 by default. Width and height must be multiples of 32, and 1920×1088 has also been tested
- Audio: 32 kHz stereo, generated in sync with the picture
- Tasks: text to video+audio (
t2va), keyframe(s) to video+audio (fl2va), references to video+audio (ref2va, up to 9 images, 3 videos and 3 audio clips, 12 in total)
With references, you put placeholders like <Picture 1> in the prompt, for example " walks through the scene from ". The GGUF versions only accept images as references. Video and audio references only work with the Python package.
How they shrank it
Video Rebirth rebuilt the MiniMax-H3 transformer in three ways:
- Pruning and low-rank factorization: Some blocks were removed from the network (3 of 50 in
fl2va, 1 of 50 inref2va). More than 100 layers were also split into smaller matrices. Think of approximating one big table with the product of two narrow ones. - Rotated INT8 quantization ("convrot"): 180 layers compute with 8-bit integers instead of larger floating-point numbers. Before quantizing, a Hadamard rotation "scrambles" the values so that individual outliers do less damage when they're stored at lower precision.
- Two-time conditioning (t, r): Diffusion models remove noise from a starting image step by step. Here, every token gets the current noise level t and also the target level r for that step. That lets the model take a few big jumps instead of many small ones. It also works without classifier-free guidance (CFG), which normally requires two passes per step.
One caveat: the system keeps the large text encoder, a part of MiniMax-H3 based on Qwen3-VL-32B. It's only trimmed and offloaded cleverly.
The numbers: speed and memory
All developer figures are for 1344×768 and 6 steps, including text encoding and decoding of video and audio.
| GPU | GGUF Q4_K_M (≥ 64 GB RAM) | GGUF, 16 GB RAM | INT8 (≥ 69 GiB RAM) |
|---|---|---|---|
| RTX 5090 (32 GB) | 99 s / 575 s | 130 s / 615 s | 92 s / 551 s |
| RTX 4090 (24 GB) | 157 s / 830 s | 153 s / 812 s | 130 s / 750 s |
| RTX 3090 (24 GB) | 315 s / 1835 s | 325 s / 1866 s | 266 s / 1684 s |
First value: 5.2-second clip. Second value: 15-second clip.
In the data center, it's much faster. A 5.2-second clip takes 36 seconds on one H200, 12.6 seconds on four H200s and 8.7 seconds on four B200s. Video Rebirth says Nvidia's SOL-H3 acceleration engine can even run the model in real time on four Blackwell GPUs. According to the developer, the INT8 version is 10 to 20 percent faster than GGUF but needs more than twice as much system RAM.
References make generation expensive. A reference image with 2048 pixels on its short side adds about 14,300 tokens. The clip itself has 37,710 tokens (5.2 s) or 109,062 tokens (15 s). Attention cost grows with the square of the token count. As a result, ref2va with two images takes 2.6 to 2.9 times as long as plain text-to-video on the INT8 transformer.
What an independent test shows
A user on note.com tested the model on an RTX 5060 Ti with 16 GB, a setup Video Rebirth hasn't benchmarked itself. He compared it with the earlier pruned INT8 version of H3 at 832×480, 124 frames and the same seed:
| Configuration | Steps | Time | Free VRAM (at peak) |
|---|---|---|---|
| Previous H3 (INT8) | 8 | approx. 130.5 s | 0.49–0.54 GB |
| HyperFlow Flash (Q4_K_M) | 6 | 130.6–132.5 s | 3.07–3.33 GB |
| HyperFlow Flash | 4 | 95.4 s | 3.07 GB |
His verdict: at 6 steps it wasn't any faster, because each step takes longer. At 4 steps it was 27 percent faster, but there was measurably less motion and more near-static frames. The clear win is memory. Instead of about 0.5 GB, a good 3 GB of VRAM stayed free, which prevents crashes on his card. Edge sharpness was marginally better with Flash.
What you need to try it
- GPU: Nvidia, Ampere generation (RTX 30 series) or newer. The official benchmarks cover 24 and 32 GB of VRAM, with peak usage of 22–28 GiB. The note.com test shows it also runs on 16 GB, preferably at a lower resolution.
- System RAM: For the GGUF variant in ComfyUI, 16 GB of RAM is enough if you launch with
--fast-diskand keep the models on an NVMe SSD. On consumer cards, the INT8 Python variant needs at least 69 GiB of RAM (with the fp8 text encoder) or 91 GiB. - Disk space: The transformer GGUF is 7.2 to 15.2 GB. On top of that come a 15.7 GB text encoder and the VAEs. The Python variant downloads about 90 GB on first launch (68 GB with fp8).
- Mac, CPU, Colab: Not supported. The Python package requires CUDA, and all benchmarked setups are Nvidia-based.
Our take
HyperFlow H3 Flash shows how far you can squeeze a large video model: half the size, few steps, audio included, all on an ordinary gaming card. If you already use MiniMax-H3 in ComfyUI, the lower memory footprint is the main draw. The speed gains on consumer hardware are modest, though. One and a half to five minutes for a 5-second clip is nowhere near real time, and the independent test puts the speed advantage further into perspective. Fewer steps also seem to cost you motion.
If you're in Europe, there's a significant catch. The weights are released under the MiniMax H3 Community License. According to Video Rebirth, it doesn't cover use in the European Union, the UK, South Korea or the US without permission from MiniMax. Using the model in those regions without explicit permission puts you outside the license, especially for commercial work. The code itself is Apache 2.0, and the ComfyUI nodes are GPL-3.0. The developer hasn't published systematic measurements of image quality compared with the full MiniMax-H3, so that remains an open question.
Sources
- Show HN (neue Projekte) github.com
- note.com note.com
Try it yourself: HyperFlow H3 Flash
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
HyperFlow H3 Flash generates short video clips of 5.2 to 15 seconds with matching stereo audio. Sound effects, ambience and music are created along with the picture. You can enter text, provide a start frame (or a start and end frame), or combine several reference images, such as a person and a location. It's less than half the size of the full MiniMax-H3 and needs only 4 to 8 steps, and that's what makes it usable on gaming GPUs in the first place. According to the developer, a 5-second clip takes about two and a half minutes on an RTX 4090 and just over five minutes on an RTX 3090. An independent test on a 16 GB card found it barely faster than the earlier H3 INT8 version, but it leaves much more VRAM free. With 4 steps it's faster, but motion gets calmer and frames more often look almost static. Real-time generation only happens on expensive data-center GPUs.
Who is it worth it for?
Worth it if you have an Nvidia card with 24 GB of VRAM or more (16 GB with compromises), already use ComfyUI and want to generate video with audio locally. If you work commercially in the EU, stay away because of the license or ask MiniMax for permission. Without an Nvidia GPU, or on a Mac, it doesn't make sense.
Ideas: What you can do with it
Describe a short scene including the soundscape and generate a 5-second clip in portrait or 16:9. You get a finished MP4 with audio that you can post straight away as a Reel or Story.
Load one of your own photos as the start frame in the hyperflow_i2v workflow and describe what should happen. You get a short clip that starts exactly with your image and has matching sound.
With hyperflow_flf2v, you provide a start and end frame, say a room before and after a makeover. The model invents the motion in between, which is handy for before-and-after videos or storyboards.
In the hyperflow_ref2v workflow, combine an image of a character with an image of a location and refer to them in the prompt with <Picture 1> and <Picture 2>. The result is a scene where your character walks through that place.
Generate several short scenes from a script to try out camera angles, mood and sound before shooting or animating. It's fast enough to compare variations, even if the clips aren't final.
What your computer needs
For home PCs with 64 GB of RAM or less, the developer recommends the GGUF files in ComfyUI. Q4_K_M (9.1 GB) is the recommended default for 24 GB cards. Q8_0 (14.9 GB) is closest to full precision if you have enough VRAM and RAM. Q3_K_M (7.2 GB) is the smallest variant, for example for 16 GB cards. For text-to-video and keyframe videos, use the fl2va_gguf folder; for reference images, use ref2va_gguf. The INT8 Python variant is only worth it on data-center GPUs or on RTX cards with 24 GB or more and at least 69 GiB of system RAM.
- Requires an Nvidia GPU from the Ampere generation (RTX 30xx) onward. Officially benchmarked on the RTX 3090, 4090 and 5090.
- Peak VRAM in ComfyUI with Q4_K_M: about 22–23 GiB on 24 GB cards and 27–28 GiB on the RTX 5090. 16 GB cards haven't been officially benchmarked, but a user test with an RTX 5060 Ti at 832×480 worked.
- GGUF runs with just 16 GB of system RAM if you launch ComfyUI with --fast-disk and keep the models on an NVMe SSD.
- Besides the transformer, you need a 15.7 GB text encoder (qwen3vl_32b_minimax_h3_nvfp4_awq). Plan for about 30 GB of disk space in total.
- Longer clips (15 s) take about five to six times as long as 5.2-second clips and need more memory.
- Reference images significantly increase compute time and memory use, because each image adds thousands of tokens.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
This model runs with its developers' own program (NVlabs/Sana on GitHub). The commands below come from the Model Card and the developers' instructions.
Windows 10 / 11
Windows 10 / 11: supported. The developer's Python variant officially supports Windows. For regular PCs with limited RAM, though, the developer recommends ComfyUI with GGUF, and that's the route we cover here. You need an NVIDIA card with 24 GB. Note: according to the license, use in the EU isn't permitted without permission from MiniMax.
- Check the requirements. You need an NVIDIA GPU from the RTX 30xx series onward with at least 24 GB of VRAM (video memory), a current NVIDIA driver, 16 GB of system RAM and about 40 GB of free disk space. You also need Python 3.10 or later and Git for Windows. Open PowerShell and check everything with the commands below.
nvidia-smi python --version git --version - Install ComfyUI. ComfyUI is the program the model runs in. Install it by following the official ComfyUI guide for Windows, ideally with its own Python environment (venv), an isolated folder just for this program. Launch it once to test. You'll end up with a folder called ComfyUI.
- Get the extensions. ComfyUI needs two extensions (custom nodes) to understand the model. ComfyUI-GGUF reads the compressed model files, and ComfyUI-HyperFlow-Flash provides the matching templates.
cd ComfyUI\custom_nodes git clone https://github.com/city96/ComfyUI-GGUF git clone https://github.com/Video-Rebirth/ComfyUI-HyperFlow-Flash - Install additional packages. First activate ComfyUI's Python environment. Then install the GGUF extension's packages and the Hugging Face download tool. If PowerShell says scripts aren't allowed to run, enter Set-ExecutionPolicy -Scope CurrentUser RemoteSigned first.
..\.venv\Scripts\Activate.ps1 pip install -r ComfyUI-GGUF\requirements.txt pip install -U huggingface_hub cd .. - Download the model. Now download the recommended Q4_K_M variant (about 9 GB) into the models\diffusion_models folder. If you need to sign in, log in first with hf auth login and accept the license on the model page.
hf download VideoRebirthAI/hyperflow-h3-flash fl2va_gguf/minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf --local-dir models\diffusion_models - Download the text encoder and VAEs. The text encoder turns your text into numbers (15.7 GB). The VAEs turn the result into picture and sound at the end. The files land automatically in models\text_encoders and models\vae.
hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors --local-dir models hf download Comfy-Org/MiniMax-H3 vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models - Launch ComfyUI. Launch ComfyUI with the --fast-disk option. It saves RAM and is recommended for PCs with 16 or 32 GB. Then open the address shown in your browser, usually http://127.0.0.1:8188.
python main.py --fast-disk - Open the template and generate your first video. Select Workflow > Browse Templates > ComfyUI-HyperFlow-Flash > hyperflow_t2v. Check that the downloaded files are selected. Enter this prompt: A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window. Then click Run. Depending on your card, this takes about 2 to 5 minutes.
- Check the result. The video with audio appears in ComfyUI and is saved in the ComfyUI\output folder. If you run out of memory, use the smaller Q3_K_M variant.
- Result. The ComfyUI/output folder contains a video about 5 seconds long with audio: a chef slides a steaming bowl of ramen across a wooden counter.
macOS
macOS: not officially tested. The developer only lists NVIDIA GPUs. Macs aren't mentioned anywhere, and the fast Python variant requires CUDA, which isn't available on the Mac. Whether the ComfyUI route works on Apple Silicon is unclear. Expect very long run times and at least 32 GB of unified memory. A Windows or Linux PC with an NVIDIA card, or a rented cloud GPU, is the more realistic option. According to the license, use in the EU isn't permitted without permission.
- Check the requirements. You need a Mac with Apple silicon (M1 or newer), as much memory as possible and about 40 GB of free disk space. Install the Xcode command line tools (they include Git) and Python 3.10 or later. Check everything in Terminal.
xcode-select --install python3 --version git --version - Install ComfyUI. ComfyUI is the program the model runs in. Install it by following the official ComfyUI guide for macOS, ideally with its own Python environment (venv). You'll end up with a folder called ComfyUI.
- Get the extensions. For ComfyUI to understand the model, clone the two extensions into the custom_nodes folder.
cd ComfyUI/custom_nodes git clone https://github.com/city96/ComfyUI-GGUF git clone https://github.com/Video-Rebirth/ComfyUI-HyperFlow-Flash - Install additional packages. Activate ComfyUI's Python environment. Then install the GGUF extension's packages and the Hugging Face download tool.
source ../.venv/bin/activate pip install -r ComfyUI-GGUF/requirements.txt pip install -U huggingface_hub cd .. - Download the model and supporting files. Download the model (Q4_K_M, about 9 GB), the text encoder (15.7 GB) and the two VAEs. The files land automatically in the right subfolders of models. Note: the nvfp4 text encoder is designed for NVIDIA cards and may not run on a Mac at all.
hf download VideoRebirthAI/hyperflow-h3-flash fl2va_gguf/minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf --local-dir models/diffusion_models hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors --local-dir models hf download Comfy-Org/MiniMax-H3 vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models - Launch ComfyUI. Launch ComfyUI with the memory-saving --fast-disk option. Then open http://127.0.0.1:8188 in your browser.
python3 main.py --fast-disk - Try your first video. Select Workflow > Browse Templates > ComfyUI-HyperFlow-Flash > hyperflow_t2v. Enter this prompt: A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window. Click Run. If it works, the video is saved in the ComfyUI/output folder. If you get error messages, your Mac probably isn't supported.
- Result. The ComfyUI/output folder contains a video about 5 seconds long with audio: a chef slides a steaming bowl of ramen across a wooden counter.
Linux
Linux: supported. Runs through ComfyUI (an interface for image and video AI) with GGUF files. The developer benchmarked it on the RTX 3090, 4090 and 5090, including on PCs with only 16 GB of system RAM. Important: according to the license, use in the EU, the UK, South Korea and the US isn't permitted without permission from MiniMax. Check this before you get started.
- Check the requirements. You need an NVIDIA GPU from the RTX 30xx series onward with at least 24 GB of VRAM (video memory), plus a current NVIDIA driver, 16 GB of system RAM and about 40 GB of free disk space. You also need Python 3.10 or later and Git. Use the commands below to check everything: nvidia-smi shows your GPU, and the other two show the version numbers.
nvidia-smi python3 --version git --version - Install ComfyUI. ComfyUI is the program the model runs in. Install it by following the official ComfyUI guide, ideally in its own Python environment (venv), an isolated folder just for this program. Launch it once to test. You'll end up with a folder called ComfyUI.
- Get the extensions. ComfyUI needs two extensions, called custom nodes, to understand the model. ComfyUI-GGUF reads the compressed model files, and ComfyUI-HyperFlow-Flash provides the matching templates. Both go into the custom_nodes folder.
cd ComfyUI/custom_nodes git clone https://github.com/city96/ComfyUI-GGUF git clone https://github.com/Video-Rebirth/ComfyUI-HyperFlow-Flash - Install additional packages. First activate ComfyUI's Python environment. Then install the packages the GGUF extension needs and the Hugging Face download tool. If the ComfyUI-HyperFlow-Flash folder also contains a requirements.txt file, install it the same way.
source ../.venv/bin/activate pip install -r ComfyUI-GGUF/requirements.txt pip install -U huggingface_hub cd .. - Download the model. Now download the recommended Q4_K_M variant (about 9 GB). It goes into the models/diffusion_models folder. If Hugging Face asks you to sign in, log in first with hf auth login and accept the license on the model page.
hf download VideoRebirthAI/hyperflow-h3-flash fl2va_gguf/minimax_h3_fl2va_hyperflow_flash_14b-Q4_K_M.gguf --local-dir models/diffusion_models - Download the text encoder and VAEs. The model needs a few supporting files. The text encoder turns your text into numbers (15.7 GB). The VAEs convert the result into picture and sound at the end. The commands automatically place everything in the right subfolders, text_encoders and vae.
hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors --local-dir models hf download Comfy-Org/MiniMax-H3 vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models - Launch ComfyUI. Launch ComfyUI from the ComfyUI folder. The --fast-disk option saves RAM and is recommended for PCs with 16 or 32 GB. Then open the address shown in the terminal in your browser, usually http://127.0.0.1:8188.
python main.py --fast-disk - Open the template and generate your first video. Click Workflow > Browse Templates > ComfyUI-HyperFlow-Flash and select hyperflow_t2v (text to video). Check that the downloaded files are selected in the loader fields. Enter the example prompt from the guide: A chef slides a steaming bowl of ramen across a wooden counter; rain taps on the window. Then click Run. This takes about 2.5 minutes on an RTX 4090 and around 5 minutes on an RTX 3090.
- Check the result. The finished video with audio appears in ComfyUI and is also saved in the ComfyUI/output folder. If the run aborts because of insufficient memory, use the smaller Q3_K_M variant.
- Result. The ComfyUI/output folder contains a video about 5 seconds long with audio: a chef slides a steaming bowl of ramen across a wooden counter.
What to do after your first result
- Change the text (prompt) in the workflow and describe your own scene. The model generates the picture and matching stereo audio at the same time.
- Use the hyperflow_i2v and hyperflow_flf2v templates to turn a start frame (or a start and end frame) into a video. The same fl2va file works for both.
- For hyperflow_ref2v (up to 12 reference images, such as a person and a location), you also need the file from the ref2va_gguf folder, for example minimax_h3_ref2va_hyperflow_flash_14b-Q4_K_M.gguf.
- Longer videos of up to 15 seconds are possible but take much longer: about 14 minutes instead of roughly 2.5 minutes on an RTX 4090.
Try it
A chef slides a steaming bowl of ramen across a wooden counter while rain pelts against the window outside.A cat jumps onto a kitchen table and knocks over a mug, which shatters with a clatter on the floor.Waves crash on a rocky coast at sunset, seagulls screech, wind rumbles in the microphone.A street musician plays the accordion in a busy market square; passersby stop and applaud.<Picture 1> walks through the street market from <Picture 2>, stops at a vegetable stall and laughs with the vendor.Tips for better results
- Start with 6 steps (the default). 4 steps is faster but, according to the user test, gives noticeably less motion. 8 steps is meant for the best quality.
- Keep CFG at 1. The model is trained to work without classifier-free guidance, so higher values won't help here.
- Test new prompts with 5.2-second clips first, possibly at a lower resolution, before rendering 15 seconds at full resolution.
- Describe sounds explicitly in the prompt (rain, voices, music), because the audio is generated from the same description.
- With reference images, the ref_image_size setting 'match' is fastest. 'max' preserves more detail but costs significantly more time and memory.
If something goes wrong
License: the MiniMax H3 Community License doesn't cover use in the EU, the UK, South Korea or the US without permission from MiniMax. Clear this up first, especially for commercial use.
ComfyUI needs two custom node packages, ComfyUI-GGUF and ComfyUI-HyperFlow-Flash, both cloned into ComfyUI/custom_nodes/. Without them, the workflow templates are missing.
On PCs with 16 or 32 GB of RAM, always launch with python main.py --fast-disk. Otherwise you'll run out of RAM on 15-second clips, or generation gets 13–21% slower.
For ref2v with large reference images (max) and 15 s clips, launch ComfyUI with --disable-cuda-malloc, or you'll get 'CUDA error: invalid argument'.
On first launch, the Python INT8 variant downloads about 90 GB and spends roughly a minute compiling kernels. On Windows you need triton-windows, and multi-GPU only works on Linux/WSL2.
Width and height must be multiples of 32, and the frame count is rounded up to 17n+5 (360 becomes 362).
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.