Best FastH3 Omni ComfyUI Workflow for 16 GB GPUs: 8-Step Reference to Video with Audio (Free JSON)

FastH3 Omni is the MiniMax H3 checkpoint everyone in my feeds is downloading this week. FastVideo’s ComfyUI repo for it passed 150,000 downloads within five days of going up, and Comfy-Org has already added an official template for it. The idea is simple: one distilled checkpoint that turns a prompt plus your reference images, videos or audio into a video with synchronized sound in just 8 sampling steps, using only core ComfyUI nodes. In this guide I walk through the files you need, which of the three ComfyUI exports makes sense on a 16 GB card like my RTX 5080, every setting in the graph and the ones you must not touch. You also get my 16 GB-friendly version of the workflow as a free download.

What Is FastH3 Omni?

FastH3 Omni (the repos also call it FastH3 OmniRef) comes from the FastVideo team at Hao AI Lab, built together with Nuva Lab, who curated the omni reference dataset. It’s a distilled version of MiniMax H3 made for the reference-to-video-and-audio task (ref2va). According to the BF16 release card:

• Inputs: a text prompt plus up to nine images, three videos and three audio clips, with at most twelve references in total. You need at least one image or video.
• Reference tags: you address the inputs in the prompt as <Picture 1>, <Video 1>, <Audio 1> in the order they’re connected. Reference videos bring their soundtracks with them.
• Output: video with synchronized 32 kHz stereo audio at 24 fps.
• Sampling: eight transformer evaluations at guidance 1.0.

The official ComfyUI template describes the checkpoint as the distilled student (step 3500), trained with trajectory-based PDD and a joint DMD loss. It’s also trained with VSA (Video Sparse Attention), which matters for the ComfyUI graph, as you’ll see below. The weights are released under the MiniMax-H3 Community License, same as the base model.

What I like about it in practice: base MiniMax H3 ref2va needs dozens of steps, and the 8-step shortcut I covered before depends on a custom loader. FastH3 Omni is a complete checkpoint that ComfyUI supports natively, so the graph is short and there’s nothing extra to install.

Why It’s Trending Right Now

A few signals made me pick this topic today:

• FastVideo/FastH3-Omni-Comfy was created on October 20, 2026 and shows over 154,000 downloads, and it sits on the Hugging Face trending list next to DeepSeek V4.1 Flash and FLUX.3 Klein.
• The NVFP4 QAD ComfyUI export (about 37,700 downloads) and the FP8 export (about 9,100) went up the same day.
• Comfy-Org added an official video_fasth3_ominiref_r2v template to workflow_templates on October 23.
• Reactor’s launch post “FastH3-Omni: The best open-source H3 model” was submitted to Hacker News on October 14 (IST).

Most of what’s online so far is model cards. There’s very little practical “which file do I pick for my GPU and why” material, so that’s what this post covers.

Files and Downloads

You need four files: one diffusion model, one text encoder, the video VAE and the audio VAE. Without the audio VAE you won’t get the synchronized soundtrack, so don’t skip it.

Which Diffusion File for a 16 GB GPU?

FastVideo publishes three ComfyUI-format diffusion exports. All go into ComfyUI/models/diffusion_models/, and you load exactly one:

File	Size	GPU	Notes
fasth3_omniref_8step_pruned_int8_convrot.safetensors	22.2 GB	Recent NVIDIA	Used by the official Comfy template; default in my workflow
fasth3_omniref_qad_nvfp4_comfy.safetensors	13.8 GB	Blackwell (RTX 50)	Quantization-aware distilled for NVFP4; smallest file
fasth3_omniref_fp8_comfy.safetensors	23.0 GB	Any FP8-capable setup	ComfyUI native FP8 layout

There’s also a 44.2 GB BF16 export, but that’s not realistic on a 16 GB card.

My pick for an RTX 5080 16 GB: the NVFP4 QAD file. “QAD” means quantization-aware distillation: the weights were trained for NVFP4 execution instead of being quantized afterwards. At 13.8 GB it’s the only export that gets close to fitting in 16 GB on its own. The model card says accelerated NVFP4 inference needs NVIDIA Blackwell, and RTX 50-series cards are Blackwell. On an RTX 30/40 card, use INT8 or FP8 and let ComfyUI offload to system RAM.

I ship the workflow with INT8 selected because that’s the file the official template is built around, and it works on more GPUs. Switching is one dropdown in Load Diffusion Model. Before recommending the swap, I read the safetensors headers of all three exports. Each one includes the to_gate_compress layers that the VSA node uses for its coarse attention branch (150 tensors in the INT8 and FP8 files, 200 in the NVFP4 file), so the same graph works with all three.

Text Encoder and VAEs

All of these are in the text_encoders/ and vae/ folders of FastH3-Omni-Comfy. The same files are in Comfy-Org/MiniMax-H3, so if you already run base H3 you probably have them.

• text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors (15.7 GB): Qwen3-VL 32B with the vision tower that reads your reference images. Accelerated NVFP4 needs Blackwell. On other GPUs, use qwen3vl_32b_minimax_h3_int8_convrot.safetensors (27.1 GB).
• vae/minimax_h3_video_vae_int8_convrot.safetensors (2.8 GB), or the fp16 video VAE (5.2 GB) if you prefer it.
• vae/minimax_h3_audio_vae_fp32.safetensors (0.6 GB): required for audio.

ComfyUI/models/
├── diffusion_models/
│   └── fasth3_omniref_qad_nvfp4_comfy.safetensors   (or the int8 / fp8 export)
├── text_encoders/
│   └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
└── vae/
    ├── minimax_h3_video_vae_int8_convrot.safetensors
    └── minimax_h3_audio_vae_fp32.safetensors

Update ComfyUI before loading the workflow. Every node it uses is a core node, but MiniMax H3 Reference to Video, Model Sparse Attention and Model Attention Backend are recent additions, and the Comfy template notes warn that Desktop builds follow stable releases and can lag behind nightly.

The Workflow, Node by Node

The graph has 25 nodes (including notes) in three lanes. I kept the official template’s wiring and changed only defaults that matter on 16 GB: resolution, duration, a single reference and a cleaner example prompt.

Model Lane: Shift, Attention Backend and VSA

1. Load Diffusion Model (UNETLoader): one of the three files above, weight dtype default.
2. ModelSamplingMiniMaxH3 (MiniMaxH3SigmaShift): shift_video 12, shift_audio 3. These are this checkpoint’s flow shifts from the model card. The video shift drives the sampler’s sigma schedule, and the audio stream gets its own shifted schedule.
3. Model Attention Backend: comfy kitchen attention, the INT8 attention kernel. This only affects the dense fallback, which is used for sequences under min_tokens and outside the sparse window. If your build doesn’t list that option (it only shows on supported NVIDIA/AMD setups), pick pytorch attention.
4. Model Sparse Attention (BlockSparseAttention): method vsa, keep_percent 10, start 0.0, end 1.0, min_tokens 12288, sink_conditioning exact_kv_and_rows. That last option keeps the packed text, audio and reference rows exact and runs the target-audio query rows dense, which protects the generated audio.

Conditioning Lane: References and Prompt

1. Load CLIP: the Qwen3-VL text encoder, type minimax.
2. Load Image: your reference, wired into ref_images.ref_image_0. That makes it <Picture 1> in the prompt. The node grows new slots as you connect more images (up to 9), and it has separate slot groups for reference videos, their soundtracks and standalone audio.
3. Resolution Selector: 16:9 at 0.5 MP with multiple 32, which gives 960×544. The template uses 1.0 MP (1376×768).
4. Float (duration) → Math Expression: converts seconds to a valid frame count on the model’s 17k+5 grid. 5 s gives 124 frames. FastVideo documents 124, 243 and 362 frames (5, 10 and 15 s) as the clip lengths.
5. MiniMax H3 Reference to Video: takes the CLIP, both VAEs, prompt, width, height and length, and outputs the conditioning plus a packed audio+video latent. ref_image_size stays on match (references are downscaled to the output size, which is faster). max keeps up to a 2048 px short edge for stronger identity, but costs speed because reference tokens are processed at every step.

Sampling and Decode

1. RandomNoise (fixed seed), KSamplerSelect euler, BasicScheduler simple, 8 steps, denoise 1.0.
2. BasicGuider: plain conditioning with no negative prompt, which matches guidance 1.0.
3. SamplerCustomAdvanced → one packed latent feeds both VAE Decode (video VAE) and VAE Decode Audio (audio VAE). Each decoder takes its own half of the latent.
4. Create Video at 24 fps muxes frames and audio. Save Video writes the MP4 to output/video/.

Settings You Must Not Change

Distilled checkpoints only work well in the setup they were trained for. The model card and the official template agree on these:

• 8 steps, guidance 1.0. Don’t add a CFG guider or a negative prompt. That isn’t how it was distilled.
• Shift 12 (video) / 3 (audio). The template specifically warns not to copy the FastH3 V2 text-to-video recipe, which uses video shift 10.
• VSA at keep 10. The template says FastH3 checkpoints are trained with VSA and must never run plain block-sparse attention, and that sol-attn and sla aren’t compatible. VSA was trained on 128-token tiles while ComfyUI uses 64-token tiles. According to the template, the difference isn’t visible.
• Reference-to-video is the job. Plain text-to-video works but isn’t its strength. Comfy ships separate FastH3 T2V and I2V templates for that.

16 GB VRAM Tips

None of FastVideo’s own local profiles target 16 GB. Their smallest consumer recipes are the RTX 5090 (32 GB, NVFP4, 480p, offloaded text encoder) and the RTX 4090 (24 GB, FP8, layerwise streaming), both documented in the local inference guide. On a 16 GB card, ComfyUI is the practical route, because it offloads weights that don’t fit to system RAM. Here’s how I’d approach it. These are setup choices, not benchmark claims, and I’m not quoting render times for this graph on my card.

• Start small, then scale. The template’s own note says VSA’s roughly 2x speedup over the INT8 attention backend shows up at full 1344×768 and 15 seconds, and short, small clips gain little. So on 16 GB, get a 960×544 / 5 s clip working first. Then raise megapixels or duration, one at a time.
• Use the NVFP4 pair on RTX 50 cards. The NVFP4 QAD diffusion file (13.8 GB) plus the NVFP4 AWQ text encoder (15.7 GB) is the lightest combination available. ComfyUI’s model management normally frees the text encoder after conditioning, before it loads the diffusion model for sampling, so the two don’t have to fit in VRAM together.
• Have plenty of system RAM and fast disk. The default file set is about 41 GB on disk. Whatever doesn’t fit in VRAM has to come from RAM, and if RAM runs out, Windows falls back to the page file, which is far slower.
• Keep ref_image_size on match until identity is clearly the problem. Reference tokens are processed at every step.
• If it runs out of memory, drop to 0.4 MP first and leave the sampler, shift and VSA settings alone. Changing those breaks the distillation without saving memory.

If you’re fighting OOMs with base H3 too, my MiniMax H3 out-of-memory fix for 16 GB covers the general ComfyUI side.

How to Write FastH3 Omni Prompts

The official template’s example prompt uses a structured layout. I use the same layout in my workflow because it makes it obvious which reference drives what:

subject_definitions:
<Subject 1> is the person in <Picture 1>: keep the exact face, hairstyle, ...

summary:
[reference generation] The target video is a 5-second, single-shot ...

retention_analysis:
<Subject 1> (appears in [Shot 1]): fully_preserved - ...

detailed_description:
[Shot 1] A medium close-up ... At 00:01.500 <Subject 1> turns to the camera
and says: "Eight steps. That's all it took."

overall_soundscape:
Light rain, distant traffic, a soft neon hum and the spoken line ...

non_diegetic_music:
A low, warm synth pad that fades in under the last second.

Practical rules I follow:

• Number the tags in the exact order the inputs are wired. <Picture 2> is whatever is plugged into the second image slot.
• Say what not to take from a reference. For example: “the reference background is not used”.
• Describe the sound explicitly: ambience, dialogue in quotes, and music in its own section. The audio follows the text.
• Use timestamps (00:01.500) for actions or cuts inside the clip.

For more prompt structure ideas, see my MiniMax H3 prompt guide. It was written for base H3, but the same tag rules apply.

FastH3 Omni vs the MiniMax H3 Acc LoRA

I recently published a MiniMax H3 8-step Acc LoRA workflow, so here’s how the two compare:

	FastH3 Omni	H3 + Ref2VA Acc LoRA
What it is	Full distilled checkpoint (FastVideo + Nuva Lab)	Adapter on the base ref2va checkpoint (Alibaba PAI)
Steps	8, guidance 1.0	8 recommended
Custom nodes	None (core only)	Needs the Deno Acc LoRA loader
Sparse attention	Trained with VSA, uses it	Not part of the recipe
Smallest diffusion file	13.8 GB NVFP4 QAD (Blackwell)	Base H3 ref2va pruned INT8 + LoRA

If you already have base H3 and use base-model LoRAs, the Acc LoRA route keeps you on one checkpoint. If you want the simplest graph, with core nodes and a model trained specifically for 8-step reference generation, FastH3 Omni is the cleaner choice.

Download the FastH3 Omni ComfyUI Workflow

The zip contains FastH3_Omni_8Step_Ref2Video_16GB.json (ComfyUI UI format, drag it onto the canvas) and a README.txt listing every model file, its download link and its folder. It’s built on Comfy-Org’s official FastH3 OmniRef template with the 16 GB defaults described above: 960×544, 5 s / 124 frames, one reference image (reference_1.png, so swap in your own), a generic example prompt and notes inside the graph. Before publishing, I validated it with a script: valid JSON, every link pointing at existing nodes and slots with matching types, and every node class checked against current ComfyUI source. No custom nodes needed. Model weights aren’t included (MiniMax-H3 Community License).

Download FastH3 Omni ComfyUI Workflow (.zip)

Requirements: current ComfyUI build, one diffusion export, the Qwen3-VL MiniMax H3 text encoder, the H3 video VAE and the H3 audio VAE (all linked above and in the README).

Frequently Asked Questions

What is FastH3 Omni?

A distilled MiniMax H3 checkpoint from FastVideo and Nuva Lab. It generates video with synchronized stereo audio from a prompt plus ordered image, video and audio references in 8 sampling steps.

Do I need custom nodes to run FastH3 Omni in ComfyUI?

No. Current ComfyUI has the MiniMax H3 Reference to Video, ModelSamplingMiniMaxH3 and Model Sparse Attention nodes in core. Just update ComfyUI.

Can FastH3 Omni run on a 16 GB GPU?

No official FastVideo profile targets 16 GB, but ComfyUI can offload weights to system RAM. On RTX 50-series cards, the 13.8 GB NVFP4 QAD export is the lightest option. Start at 960×544 and 5 seconds. Speed depends heavily on your RAM and how much has to be offloaded.

Can I use the NVFP4 file on an RTX 4090 or 3090?

The model card says accelerated NVFP4 inference requires Blackwell and recommends BF16 or FP8 on other GPU families. On RTX 30/40 cards, use the INT8 or FP8 export with the INT8 text encoder.

Can it do plain text-to-video?

It can, but the template notes say that isn’t its strength, and at least one image or video reference is expected. For text-only work, use the FastH3 text-to-video template.

How long can the clips be?

FastVideo documents 124, 243 and 362 frames (5, 10 and 15 seconds at 24 fps). The ComfyUI node snaps length to the 17k+5 grid and calls about 124 to 362 frames the trained range.

Can I use the output commercially?

The weights are governed by the MiniMax-H3 Community License Agreement. Read it on the MiniMax-H3 repo before using output commercially.

Sources

• FastVideo/FastH3-Omni-Comfy (ComfyUI INT8/BF16 exports, text encoders, VAEs)
• FastVideo/FastH3-Omni-NVFP4-QAD-Comfy and FastH3-Omni-FP8-Comfy
• FastH3 Omni BF16 release card
• FastVideo: FastH3 OmniRef local inference guide
• Comfy-Org official template video_fasth3_ominiref_r2v.json
• ComfyUI nodes_minimax_h3.py and nodes_sparse_attention.py
• Reactor: FastH3-Omni launch post and Nuva Lab FastH3 page