TL;DR: MiniMax H3’s community GGUF builds run in ComfyUI today through the standard ComfyUI-GGUF custom node — UNet GGUF in models/unet/, text encoder in models/text_encoders/, two VAEs in models/vae/. But the quant menu isn’t what it looks like: H3’s denoiser can’t take real K-quants (its 2,688-wide tensors aren’t divisible by 256), so “Q4_K_M” files are mostly classic Q4_0/Q4_1 under the label. Pick by file size, not suffix, and grab the Turbo LoRA — it cuts sampling from ~20 steps to 6–8.

	12–16GB card (3060, 4070, 5060 Ti)	24GB card (3090, 4090)	32GB card (RTX 5090)
Quant to download	Q2–Q3mix UNet (8.5–17.3GB)	Q4-class GGUF (~19.9GB) or pruned INT8	Q5-class GGUF (~23.9GB) or NVFP4 pruned
Realistic render	0.4MP template, minutes per second of video	~6 min per 20s clip (FP8 path, tested)	175s per 10s clip (NVFP4, 10 steps)
The catch	32GB+ system RAM and NVMe are mandatory	~46GB total peak spills into system RAM	NVFP4 speedup is Blackwell-only

Honest take: the GGUF path is the only way most cards touch this model, and it works — but it’s community-maintained, unofficial, and moving weekly. Budget an evening for setup, keep ComfyUI and ComfyUI-GGUF both updated, and read the license section before you download anything: if you’re in the US, EU, UK, or South Korea, local H3 deployment isn’t licensed, full stop.

Our MiniMax H3 hardware guide covered what the 33B video-plus-audio model needs from your GPU and why the Community License locks out most of our readers. This is the companion piece for everyone who can legally run it: the actual ComfyUI workflow, file by file, with the traps the model-card READMEs don’t mention.

The license warning, one more time

MiniMax H3’s Community License excludes the United States, European Union, United Kingdom, and South Korea from local deployment without separate written authorization (TechTimes, Aug 4 2026). That’s a license term, not a technical block — the files download fine, which is exactly why it’s worth repeating. If you’re in an excluded territory, this tutorial is research reading; the compliant options are the hosted Hailuo API or Wan for local video. Everyone else, carry on.

What you’re actually assembling

A working H3 GGUF stack in ComfyUI is four pieces, and the UNet file everyone screenshots is the smallest surprise of the four:

Piece	What it is	Where it goes	Size range
Denoiser (DiT) GGUF	The 33B video model, quantized	ComfyUI/models/unet/	8.5–36GB
Text encoder	Qwen3-VL-32B, GGUF or safetensors	ComfyUI/models/text_encoders/	~14.6–27.1GB
Video VAE	minimax_h3_video_vae_fp16.safetensors	ComfyUI/models/vae/	~5.8GB combined
Audio VAE	minimax_h3_audio_vae_fp32.safetensors	ComfyUI/models/vae/	(with video VAE)

The text encoder is the budget-killer people miss. It’s a 32B vision-language model — bigger than many people’s main LLM — and the community pairs quantized like the joeygambino encoder GGUFs run 14.6–27.1GB depending on quant. When someone says “the Q4 is only 20GB,” they’re quoting the UNet alone. Budget for the full stack, plus 32GB minimum system RAM for ComfyUI’s offloading to have somewhere to spill.

Baseline software: ComfyUI 0.30.0 or later (H3 support landed in core via PR #15224 on release day, so the official workflows need no custom nodes) and the ComfyUI-GGUF node for the quantized path:

cd ComfyUI/custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
pip install --upgrade gguf
# restart the ComfyUI server — not the browser tab

On the Windows portable build, run the pip install with the embedded interpreter (.\python_embeded\python.exe -m pip install --upgrade gguf), or a custom node’s dependency lands in the wrong Python and you get the classic red IMPORT FAILED banner — we decoded that whole failure class in the IMPORT FAILED fix guide.

The K-quant trap: why “Q4_K_M” isn’t what it says

Here’s the correction to what you’ll read on Reddit. For LLMs, Q4_K_M is the default download and we’ve recommended it across the whole site. For H3’s denoiser, true K-quants are architecturally impossible: K-quants require weight-row dimensions divisible by 256, and H3’s hidden width is 2,688 — not divisible (minimaxh3.co GGUF breakdown). The quantizer falls back to classic types (Q4_0, Q4_1, Q5_0, Q5_1) on those tensors, whatever the filename claims.

You can see it in the file listings of the main community repo, vantagewithai/MiniMax-H3-comfyUI-GGUF: “Q4_K_M,” “Q4_K_S,” and plain “Q4_0” are all the same 19.9GB, because they’re substantially the same file. The honest menu, by size:

DiT quant (label)	File size	Fits resident on
Q2	8.49GB	12GB cards (tight, with offload)
Q3-class / Q3mix	15.6–17.3GB	16GB cards with light streaming, 20GB+ comfortable
Q4-class (Q4_0/Q4_1/“Q4_K_M”)	19.9–21.9GB	24GB cards
Q5-class (Q5_0/Q5_1/“Q5_K_M”)	23.9–25.9GB	32GB cards
Q6_K	28.2GB	32GB cards (tight)
Q8_0	36GB	Nothing consumer, resident

Two practical consequences. First, don’t burn bandwidth downloading three Q4 variants expecting quality differences — check file sizes first; identical size means near-identical tensors. Second, the text encoder is a normal Qwen3-VL-32B whose dimensions do permit real K-quants, so a Q4_K_M encoder GGUF (~19.8GB, ~16.5GB resident per the community listings) behaves exactly like the K-quants you know from LLM-land. Same suffix, two different realities, one workflow.

None of this exists officially, and that’s worth saying plainly: MiniMax and Comfy-Org publish no H3 GGUF. The Comfy-Org repack is bf16, INT8, and pruned-INT8 safetensors (~343GB whole repo — download individual files, never clone it). The GGUFs are community conversions from vantagewithai, joeygambino, unsloth, and others. Quality and compatibility ride on those maintainers keeping pace with ComfyUI.

Wiring the workflow

Start from the built-in template (Workflow → Browse Templates → Video → MiniMax H3) — it ships in ComfyUI 0.30.0+ and pulls the official Comfy-Org file set. To convert it to the GGUF stack, you swap two loaders (kombitz’s T2V/I2V walkthrough is the reference here, and the official ComfyUI tutorial documents the stock version):

1. Replace “Load Diffusion Model” with “Unet Loader (GGUF)” and point it at your DiT quant in models/unet/. If the file doesn’t appear in the dropdown, use the Refresh action — a browser reload does not rescan the model folders (the #1 wasted half hour, same as in our failed-validation guide).
2. Text encoder: if you’re using a safetensors encoder like qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors, the standard loader handles it; a GGUF encoder loads through ComfyUI-GGUF’s CLIPLoader (gguf) node instead.
3. Both VAEs stay stock — video VAE fp16, audio VAE fp32, loaded exactly as the template wires them.
4. Prompt, set resolution and frame count, queue. The same graph switches between text-to-video, image-to-video, and first/last-frame modes, so one working setup covers all three.

One version note: early GGUF conversions needed a one-line architecture patch to ComfyUI-GGUF (the H3-Multishot node pack bundled it). Current ComfyUI-GGUF handles H3 directly — if you see an unknown-architecture error on load, update the custom node before touching the files. It’s the video-gen cousin of the unknown model architecture error we cataloged for LLM GGUFs.

Settings that match your card

Start conservative and scale up: 864×480, 121–243 frames (5–10 seconds at 24 FPS), 20 steps on the stock sampler. Resolution and frame count multiply into VRAM pressure; steps only multiply time.

Real, measured numbers to calibrate against:

• RTX 5090, NVFP4 pruned build: 243-frame, 10.1-second 864×480 clip with audio at 10 steps — 175 seconds, 26,914 MiB peak VRAM (ai-muninn benchmark).
• RTX 5090, Q5_1 GGUF: ~22GB resident, ~10.3 minutes for a 243-frame 544×960 shot at 20 steps (minimaxh3.co).
• RTX 4090, FP8 + AWQ encoder: ~6 minutes per 20-second clip; total memory peaked around 46GB with system RAM absorbing the spill (minimaxh3.co ComfyUI guide).
• RTX 3060 12GB, 32GB RAM, NVMe: the 0.4-megapixel, 124-frame template completes on full dynamic offload. It finishes; nobody calls it fast.

If sampling dies mid-run with torch.OutOfMemoryError: Allocation on device, the fix order is: smaller DiT quant → enable SageAttention → lower resolution before frame count → let ComfyUI’s dynamic offloading work instead of forcing weights resident. The general VRAM triage lives in the CUDA OOM guide.

NVFP4 vs GGUF: the Blackwell question

The queue of Reddit posts asking “should I grab NVFP4 instead?” has a two-line answer with a twist.

NVFP4’s speed is Blackwell-only. RTX 50-series cards have hardware FP4 paths; the 31.7GB pruned NVFP4 set is why a single RTX 5090 renders sub-3-minute clips, and we walked the format’s mechanics in the ComfyUI NVFP4 guide. On Ada and older, the twist: it still runs — Kijai, who maintains the Comfy-Org repack, put it flatly: “The nvfp4 is not for Blackwell only, you can just use it” (Comfy-Org discussion). But pre-Blackwell hardware dequantizes NVFP4 weights back to high precision before every matmul, so you get the small file and zero speedup.

So the decision is clean: RTX 5090 → NVFP4 pruned. RTX 4090/3090 → pruned INT8 (or the Q4-class GGUF) — same disk-space ballpark, and the compute path your card actually accelerates. The INT8-ConvRot conversions floating around (e.g. Abiray’s set) exist precisely for the Ada crowd.

The Turbo LoRA: 20 steps → 8

The biggest speed win since release isn’t a quant at all. On August 5, larryvrh shipped a distillation LoRA that renders H3’s joint video-plus-audio in 4–8 sampling steps instead of ~20 (Turbo LoRA on Hugging Face, ComfyUI Wiki coverage). At 20-step renders measured in many minutes, cutting steps 60–80% is worth more than any quant swap on the menu.

Setup, per the companion node repo:

cd ComfyUI/custom_nodes
git clone https://github.com/larryvrh/ComfyUI-MiniMax-H3-Turbo
# LoRA file → ComfyUI/models/loras/

Use the v4 checkpoint (minimax_h3_turbo_v4_step600_ema.safetensors) — it fixed the over-sharpened plastic look of the v1 line and handles static shots and fine detail (faces, fingers) markedly better. Recommended settings from the repo: LoRA strength 1.0, scheduler simple, steps 6–8 for the quality sweet spot; 4 steps works for drafts but renders softer.

The custom node earns its keep on the audio side. H3 denoises video and audio on two different flow schedules (video shift 12, audio shift 3), and at 4 steps a naive sampler steps them together — that’s the crunchy audio people reported in week one. The node’s dual-clock sampler steps each stream on its own schedule on older ComfyUI builds and auto-detects when core handles it natively. It also streams the base model, which is a quiet gift to smaller GPUs — there’s a low_vram mode for constrained setups.

Stack it with the GGUF workflow: Q4-class UNet + Turbo LoRA at 8 steps turns a 24GB card’s many-minutes render into low-single-digit minutes territory. That combination — not NVFP4, not a bigger card — is the most practical upgrade for the 3090/4090 crowd this month. If you’d rather benchmark before committing your own disk space, a RunPod 5090 or A100 instance is the cheap way to test the full-precision path against your quant of choice for an hour.

FAQ

Is there an official MiniMax H3 GGUF? No. MiniMax publishes safetensors; Comfy-Org repacks bf16/INT8/pruned-INT8 and NVFP4-AWQ encoders. All GGUFs are community conversions — vantagewithai, joeygambino, and unsloth are the repos with the most complete quant ladders as of mid-August 2026.

Why is Q4_K_M the same size as Q4_0 for this model? Because H3’s denoiser tensors (hidden width 2,688) aren’t divisible by 256, which real K-quants require. The quantizer falls back to classic Q4_0/Q4_1 for those tensors, so the K-labeled files are K-quants in name only. The Qwen3-VL text encoder doesn’t share this limit — its K-quants are real.

Can my RTX 4090 use the NVFP4 files? It will load and run them — but Ada emulates FP4 by dequantizing before each matmul, so there’s no speedup, only the smaller download. Use pruned INT8 or a Q4-class GGUF instead; save NVFP4 for Blackwell.

Do I need the Turbo LoRA node pack, or just the LoRA file? Recent ComfyUI builds can apply the LoRA with the built-in loader, but the node pack’s dual-clock sampler is what keeps audio clean at very low step counts on older builds, and its model streaming helps low-VRAM cards. If you’re at 6–8 steps on current ComfyUI, the file alone usually suffices.

Is any of this legal to run in the US or EU? The H3 Community License excludes US, EU, UK, and South Korea local deployment without written authorization from MiniMax. The hosted API is available everywhere; for local video in excluded territories, Wan (Apache 2.0) remains the recommendation.

Recommended Gear

• RTX 5090 — the only consumer card with the FP4 hardware path and the 32GB to hold the NVFP4 build resident
• RTX 4090 — the 24GB GGUF/INT8 sweet spot, especially with the Turbo LoRA
• 64GB DDR5 kit — H3’s offload spill lives in system RAM; 32GB is the floor, 64GB is comfortable

Sources

• MiniMax-AI/MiniMax-H3 — GitHub (architecture, checkpoints, license)
• MiniMax H3: ComfyUI Workflow Examples — ComfyUI Docs
• city96/ComfyUI-GGUF — GitHub (GGUF loader node)
• vantagewithai/MiniMax-H3-comfyUI-GGUF — Hugging Face (DiT quant ladder)
• joeygambino/MiniMax-H3-encoder-GGUF — Hugging Face (text encoder quants)
• MiniMax H3 GGUF: Quant Levels, Sizes & Low-VRAM Setup — minimaxh3.co
• MiniMax H3 GGUF in ComfyUI: T2V & I2V Guide — kombitz
• Running MiniMax-H3 on one RTX 5090: four files, 31.7GB, 175s per clip — ai-muninn
• Which model to pick for RTX 5090? — Comfy-Org/MiniMax-H3 discussion (Kijai on NVFP4)
• larryvrh/MiniMax-H3-Turbo-Lora — Hugging Face
• Larryvrh/ComfyUI-MiniMax-H3-Turbo — GitHub (dual-clock sampler node)
• MiniMax H3 Turbo LoRA: 4-Step Audio-Video Generation — ComfyUI Wiki
• MiniMax H3 Open Weights Exclude US, EU, UK, and Korea — TechTimes

Last updated August 11, 2026. Community quants, node packs, and license terms change fast; verify current files and terms before downloading.