ComfyUI-HyperFlow-Flash Introduction
ComfyUI-HyperFlow-Flash brings HyperFlow H3 Flash into ComfyUI through dedicated model-loading nodes, a sampling-schedule node, and ready-to-use workflows.
HyperFlow H3 Flash is a compressed, few-step version of MiniMax-H3. It generates video and synchronized stereo audio together, rather than requiring you to create a silent video and add a separate soundtrack afterward.
The extension helps you:
- Create clips from text: Describe a scene, its action, and its sounds.
- Animate a starting image: Use an image as the first frame of your video.
- Guide a transition between two images: Supply both the first and last keyframes.
- Create videos guided by reference images: Use the reference workflow and its dedicated model.
- Generate with only 4, 6, or 8 sampling steps: Choose between quicker experiments and more refinement.
- Use compressed model files: Choose GGUF or ComfyUI-compatible INT8 safetensors according to your hardware.
The underlying model supports approximately 5.2–15 seconds of video at 24 frames per second, with 1344 × 768 as its default landscape resolution and a 32 kHz stereo soundtrack. Actual generation time and memory use depend on your GPU, clip length, resolution, references, and model format.
Compatibility: The extension requires ComfyUI 0.43.0 or newer, with native MiniMax-H3 support. GGUF checkpoints additionally require ComfyUI-GGUF; INT8 safetensors do not.
How ComfyUI-HyperFlow-Flash Works
From your idea to an audiovisual clip
A workflow connects several components, each with a specific job:
-
The text encoder interprets your prompt.
It converts your description into information the generation model can use. -
The HyperFlow model builds the video and audio.
It starts from noise and refines it over a small number of steps. Depending on the workflow, it also receives a starting image, two keyframes, or reference images. -
The video and audio VAEs decode the result.
A VAE is a component that converts the model’s compact internal representation into visible frames or an audible soundtrack. -
The workflow prepares the output.
The supplied templates connect these components so you do not need to build the entire process from scratch.
For example, you might describe:
A chef slides a steaming bowl of ramen across a wooden counter while rain taps against the window.
The prompt describes both visible action and sound, giving the model information for the combined audiovisual result.
Why the model is smaller
HyperFlow H3 Flash reduces the size of the original MiniMax-H3 transformer in two main ways:
- Pruning: Some processing blocks are removed.
- Low-rank factorization: Some large calculations are replaced with smaller, more compact calculations.
Think of this as reorganizing a large artist’s toolkit into a lighter kit designed for the same type of work. The resulting generation models contain approximately 13.7 or 13.9 billion parameters, compared with roughly 31 billion in the original MiniMax-H3 transformer.
What GGUF and INT8 mean
Both formats store model information using less numerical precision to reduce its footprint.
- GGUF offers several compression levels. Smaller files save space, but more aggressive compression can affect fidelity.
- INT8 convrot safetensors use 8-bit calculations for selected layers. In this extension, these layers use ComfyUI’s native INT8 execution, while the low-rank layers remain in bfloat16, a higher-precision format.
A smaller model file does not mean the entire workflow uses that amount of memory. The text encoder, VAEs, and temporary generation data also need memory.
Why only a few sampling steps are needed
HyperFlow uses two-time conditioning, written as (t, r). In simple terms, the model receives both its current noise level and the destination of the next step.
An analogy is giving an artist both the current sketch and a clear target for the next revision. This allows the model to work with its specialized 4-, 6-, or 8-step schedules.
The supplied schedules use CFG = 1.0, meaning no additional classifier-free guidance is applied. Start with the provided settings rather than transferring high-CFG settings from unrelated workflows.
ComfyUI-HyperFlow-Flash Features
HyperFlow Loader
HyperFlow Loader loads either:
- HyperFlow GGUF checkpoints.
- HyperFlow INT8 convrot safetensors prepared specifically for ComfyUI.
It understands the compressed structure and two-time conditioning used by these checkpoints.
For GGUF files, it exposes:
| Setting | Purpose |
|---|---|
weights_in: auto | Lets the loader choose how to handle the GGUF weights. |
weights_in: disk | Selects disk-backed weight handling. |
weights_in: ram | Selects RAM-based weight handling. |
These options affect model loading and memory handling, not the artistic content of your prompt. They apply to GGUF files only. Consult the integration guide before changing memory-related settings on a constrained system.
For longer INT8 clips, the loader processes certain calculations in smaller row chunks. This keeps those operations within the indexing limits of ComfyUI’s Triton kernels.
HyperFlow GGUF Loader
HyperFlow GGUF Loader is the GGUF-only loader from version 1.0.0.
It remains available for compatibility, so workflows saved with this node continue to work. You do not need to replace it simply because the newer, combined HyperFlow Loader exists.
HyperFlow Sigmas
HyperFlow Sigmas produces the noise schedule used during generation. You can think of this schedule as the plan for how much refinement happens at each step.
| Steps | Suggested use | Trade-off |
|---|---|---|
| 4 | Quick drafts and testing ideas | Prioritizes speed. |
| 6 — default | Everyday generation | Balances speed and refinement. |
| 8 | A more quality-focused attempt | Takes more sampling work and time. |
More steps do not guarantee a better result for every prompt. A practical approach is to explore ideas at 4 or 6 steps, then compare an 8-step version once the composition and action are promising.
Use the schedules at CFG = 1.0.
Ready-to-use workflow templates
The extension includes four workflow types, each available in GGUF and INT8 versions:
| Creative task | GGUF template | INT8 template | Inputs |
|---|---|---|---|
| Text to video and audio | hyperflow_t2v | hyperflow_t2v_int8 | A text prompt |
| Image to video and audio | hyperflow_i2v | hyperflow_i2v_int8 | A prompt and first image |
| First/last frame to video and audio | hyperflow_flf2v | hyperflow_flf2v_int8 | A prompt, first image, and last image |
| Reference-guided video and audio | hyperflow_ref2v | hyperflow_ref2v_int8 | A prompt and reference images |
Find them under:
Workflow → Browse Templates → ComfyUI-HyperFlow-Flash
The workflow files are also available in example_workflows/.
For example:
- Choose t2v to develop a scene entirely from a written idea.
- Choose i2v to animate an existing illustration.
- Choose flf2v when you want to guide both the beginning and ending of a shot.
- Choose ref2v when reference images should guide the generated scene rather than simply act as its endpoints.
Reference image sizing
The documented GGUF reference workflow includes a ref_image_size setting:
match— default: Reduces reference images to the output’s pixel area while preserving each image’s aspect ratio.max: Only reduces reference images when their short edge exceeds 2048 pixels.
Larger references add more information for the model to process at every sampling step. This can substantially increase generation time and memory use.
For everyday reference-guided experiments, start with match. Use max only when you specifically want to test larger references and have enough memory.
ComfyUI-HyperFlow-Flash Models
Choose the model family for your task
There are two main checkpoint families:
| Family | Approximate parameters | Use it for |
|---|---|---|
fl2va | 13.7 billion | Text-to-video, image-to-video, and first/last-frame workflows |
ref2va | 13.9 billion | Reference-guided generation |
You do not need a separate text-to-video checkpoint: the fl2va family also serves text-only generation.
The checkpoints are available from VideoRebirthAI/hyperflow-h3-flash.
GGUF checkpoints
GGUF files are organized into:
fl2va_gguf/ref2va_gguf/
Available compression levels include:
| GGUF variant | fl2va file size | ref2va file size | When to consider it |
|---|---|---|---|
Q3_K_M | 7.2 GB | 7.4 GB | Smallest available footprint |
Q4_K_M | 9.1 GB | 9.2 GB | Recommended GGUF starting point |
Q8_0 | 14.9 GB | 15.2 GB | Closest to full precision when memory allows |
Q4_K_S, Q5_K_M, and Q6_K are also available as intermediate choices.
Higher precision can preserve more model information, but it does not guarantee a visibly better result for every scene. Compare variants using the same workflow and prompt if you want to judge the trade-off for your work.
INT8 convrot safetensors
For this extension, use the single-file checkpoints from:
fl2va_int8_convrot_comfyui/ref2va_int8_convrot_comfyui/
These are the ComfyUI-specific files, not the separate folders intended for the standalone Python runtime.
The author recommends INT8 safetensors for ComfyUI on RTX GPUs with 24 GB or more VRAM, with 16 GB or more system RAM, provided a compatible INT8 backend is available. The documented backend choices are a PyTorch build for CUDA 13.0 or newer, or ComfyUI’s --enable-triton-backend option.
Published same-machine comparisons found ComfyUI INT8 approximately 5–15% faster than GGUF Q4_K_M in the tested configurations. Treat this as a benchmark result, not a guaranteed speed increase on every computer.
Companion models
Both checkpoint formats use additional MiniMax-H3 components from Comfy-Org/MiniMax-H3:
| Component | File | Role |
|---|---|---|
| Text encoder | qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors | Interprets your prompt; approximately 15.7 GB |
| Video VAE | minimax_h3_video_vae_fp16.safetensors | Decodes video frames |
| Audio VAE | minimax_h3_audio_vae_fp32.safetensors | Decodes audio |
When checking model selections, the expected folders are:
- HyperFlow checkpoints:
ComfyUI/models/diffusion_models/ - Text encoder:
ComfyUI/models/text_encoders/ - Both VAEs:
ComfyUI/models/vae/
Hardware expectations
Published ComfyUI tests include 24 GB and 32 GB consumer GPUs, including systems with 16 GB of system RAM.
For perspective, the reported text-to-video benchmarks at 1344 × 768 and 6 steps include:
| GPU | ComfyUI INT8: 5.2-second clip | ComfyUI INT8: 15-second clip |
|---|---|---|
| RTX 5090, 32 GB | 83 seconds | 518 seconds |
| RTX 4090, 24 GB | 152 seconds | 747 seconds |
These runs did not include saving the MP4. Your results may differ because of memory availability, storage, software versions, and workflow settings.
16 GB GPUs had not been measured in the supplied documentation. Do not interpret GGUF file sizes or general ComfyUI hardware claims as confirmation that this complete workflow will fit on a particular GPU.
What’s New with ComfyUI-HyperFlow-Flash
The available documentation identifies version 1.0.0 for the original GGUF-only loader, but does not provide a complete version-by-version changelog.
The documented additions and compatibility improvements are:
- Unified HyperFlow Loader: Loads both GGUF and supported INT8 safetensors, giving you a choice of formats in one loader.
- INT8 workflow templates: All four workflow types have matching
*_int8versions. - Native ComfyUI INT8 execution: Quantized layers use ComfyUI’s INT8 kernels, while low-rank layers remain in bfloat16.
- Long-clip INT8 chunking: Large operations are divided into smaller pieces to stay within kernel indexing limits.
- Safetensors format checks: The loader checks HyperFlow metadata and rejects layouts newer than it understands, with a message to update the node pack.
- Backward compatibility: Existing workflows using HyperFlow GGUF Loader remain supported.
- Template-menu integration: Workflows appear directly in ComfyUI’s template browser.
For current repository activity, see ComfyUI-HyperFlow-Flash on GitHub.
Troubleshooting ComfyUI-HyperFlow-Flash
My checkpoint does not appear in HyperFlow Loader
- Check that the checkpoint is in
ComfyUI/models/diffusion_models/. - Confirm that you selected a HyperFlow checkpoint, not a companion text encoder or VAE.
- For INT8, confirm that it came from a folder ending in
_int8_convrot_comfyui. - Remember that the loader lists safetensors only when they contain the required
hyperflowmetadata.
A .safetensors filename alone does not make a checkpoint compatible.
The loader says the checkpoint layout is too new
- Read the update message shown by the loader.
- Update the ComfyUI-HyperFlow-Flash node pack.
- Restart ComfyUI and load the checkpoint again.
This check prevents an older loader from misreading a newer model layout.
GGUF generation runs out of system RAM or becomes unusually slow
For GGUF workflows on PCs with 16 GB or 32 GB of system RAM, the author recommends launching ComfyUI with:
python main.py --fast-disk
- Close the current ComfyUI session.
- Add
--fast-diskto your usual launch configuration. - Keep the models on fast storage; the published low-RAM tests used NVMe storage.
- Retry the supplied workflow before changing other memory settings.
Without this option, GGUF weight handling can consume additional system RAM when GPU memory overflows. The documented 16 GB systems could run out of RAM on 15-second clips.
This recommendation is GGUF-specific. The author also reports ComfyUI INT8 runs with approximately 12 GiB of system RAM available to ComfyUI, without --fast-disk.
INT8 generation fails with a backend-related error
- Confirm that ComfyUI is version 0.43.0 or newer.
- Confirm that you are using a ComfyUI-specific INT8 checkpoint and its matching template.
- Check the documented INT8 backend requirement: a PyTorch build for CUDA 13.0 or newer, or
--enable-triton-backend. - Consult the ComfyUI INT8 guide for environment-specific details.
ComfyUI-GGUF is not required for INT8 safetensors and does not replace the INT8 backend requirement.
Reference-guided generation is much slower than text-to-video
References add extra information that must be processed during every sampling step.
- Start with fewer reference images.
- In the documented GGUF workflow, use
ref_image_size: match. - Test a shorter clip before attempting a 15-second version.
- Change one setting at a time so you can identify the main source of the slowdown.
Large reference images can be especially expensive even when the output resolution stays unchanged.
A long GGUF reference clip reports CUDA error: invalid argument
The author documents this error for 15-second reference clips using ref_image_size: max with the default CUDA memory allocator.
- Check whether your workflow matches that configuration.
- Try
ref_image_size: matchif large references are unnecessary. - If you need
max, the documented workaround is:
python main.py --disable-cuda-malloc
This is a workaround for a specific tested configuration, not a setting that every workflow requires.
Frequently asked questions
Does the extension generate audio too?
Yes. HyperFlow H3 Flash generates video and synchronized stereo audio together. The workflow uses separate video and audio VAEs to decode them.
Which settings should I start with?
Use a supplied template, 6 steps, and CFG = 1.0. For GGUF, Q4_K_M is the recommended starting point.
Can I use an ordinary MiniMax-H3 checkpoint with HyperFlow Loader?
The loader is designed for the supported HyperFlow compressed checkpoints. Native MiniMax-H3 support in ComfyUI does not make every MiniMax-H3 checkpoint interchangeable with these files.
Can the ComfyUI reference workflow use video and audio references?
The supplied documentation explicitly describes image references for the ComfyUI/GGUF reference path. Mixed image, video, and audio references are documented for the separate Python INT8 runtime. Do not assume that those capabilities are exposed by these ComfyUI templates.
Do I need to replace HyperFlow GGUF Loader in an older workflow?
No. The author retains that node for compatibility.
Does an 8-step run always look better?
No. Eight steps are the quality-focused option, but the result still depends on the prompt, inputs, and scene. Compare outputs rather than assuming a universal improvement.
Learn More about ComfyUI-HyperFlow-Flash
- HyperFlow integration guide — Detailed ComfyUI guidance, memory considerations, benchmarks, and troubleshooting.
- HyperFlow model page — Available checkpoint files, model details, and licensing information.
- Example workflows — The supplied workflows for text, keyframe, and reference-based generation.
- HyperFlow H3 Flash documentation — Broader information about the model, supported runtimes, and performance. Some features described there belong to the separate Python runtime.
- MiniMax-H3 companion models — The text encoder and VAEs used by these workflows.
- ComfyUI workflow examples — General examples to help you understand ComfyUI’s visual workflow approach.
- ComfyUI-GGUF documentation — Background on GGUF support. For HyperFlow-specific model locations and loading, follow this extension’s documentation.
ComfyUI-HyperFlow-Flash License
Extension code: GPL-3.0. See LICENSE.
Model weights: Distributed separately under the MiniMax H3 Community License Agreement, not GPL-3.0.
The agreement includes an Acceptable Use Policy and does not cover use in the European Union, United Kingdom, Republic of Korea, or United States without MiniMax’s authorization.
Review the model agreement before using the checkpoints. The extension’s code license does not replace or override the model-weight terms.
