TL;DR
- GGUF builds for MiniMax H3 are community-maintained, not an official MiniMax or Comfy-Org release. They work well, but aren't part of the documented official workflow — see Is GGUF Officially Supported? below.
- UNet quant sizes range from 15.6GB (Q3_K_S/M) up to 23.9GB (Q5_K_M/S). You also need a text encoder (14.6GB–27.1GB) and VAE (~5.8GB combined) on top.
- Rule of thumb from the community: Q3 = wider compatibility, lower quality. Q4 = the general recommendation. Q5 = closest to full precision, needs more VRAM.
- Quantization doesn't fix the model's underlying output issues (audio, physics, hand/object consistency) — it can only match or fall below the quality we measured on the full-precision path. See Real Output Quality.
- No GPU that fits any of this? Try MiniMax H3 online at full 2K, no quantization decisions required.
Is GGUF Officially Supported?
No. MiniMax's own release and the official Comfy-Org Day-0 build (covered in the ComfyUI setup guide) do not include a GGUF package. The GGUF conversions in this guide are community-maintained repositories on Hugging Face — well-used (one of the repos referenced here has 80,000+ monthly downloads) but not something MiniMax or Comfy-Org documents or officially supports. If a GGUF-specific node throws an error, the official channels won't have a fix for it — check the community repo's discussion tab instead.
Two Model Variants — Pick Based on Your Inputs
MiniMax H3's GGUF conversions ship as two separate base models. You need the one that matches how you plan to use it, not both.
FL2VA (First-and-Last-Frame Mode)
Handles zero, one, or two image inputs:
- No image → text-to-video
- One image → first-frame or last-frame-to-video
- Two images → first-and-last-frame-to-video
Ref2VA (Omni-Reference Mode)
Handles multi-modal reference inputs: up to 9 images, 3 video clips (2–15s each, ≤15s total), and 3 audio clips (must accompany an image/video input, not standalone) — 12 files maximum combined.
Quantization Levels and File Sizes
Real file sizes from the community GGUF release (identical across FL2VA and Ref2VA):
UNet (Diffusion Model)
| Quant | File Size | Notes |
|---|---|---|
| Q3_K_S | 15.6 GB | Smallest, widest compatibility, most quality loss |
| Q3_K_M | 15.6 GB | Same size as Q3_K_S, slightly different weighting |
| Q4_0 | 18.6 GB | Basic 4-bit |
| Q4_K_S | 19.9 GB | Community-recommended baseline |
| Q4_K_M | 19.9 GB | Community-recommended baseline |
| Q5_0 | 22.8 GB | Closer to full precision |
| Q5_K_S | 23.9 GB | Closer to full precision |
| Q5_K_M | 23.9 GB | Closest to full precision in this lineup |
Text Encoder (Required Separately)
| File | Size | Type |
|---|---|---|
qwen3vl_32b_minimax_h3-Q4_K_M.gguf | 14.6 GB | GGUF-quantized — pairs naturally with a quantized UNet |
qwen3vl_32b_minimax_h3_int4_convrot.safetensors | 15 GB | int4, non-GGUF |
qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors | 27.1 GB | Highest precision, largest — this is the variant used in our own tested RTX 4090 workflow |
VAE (Required)
| File | Size |
|---|---|
minimax_h3_video_vae_fp16.safetensors | 5.21 GB |
minimax_h3_audio_vae_fp32.safetensors | 605 MB |
Total footprint = UNet + text encoder + VAE. With CPU/GPU offloading, peak resident VRAM during generation is lower than the sum, but plan disk space for the full combined size.
Which Quant Level Fits Your GPU
| Your GPU | Suggested UNet | Suggested Text Encoder | Tradeoff |
|---|---|---|---|
| 12GB (e.g. RTX 3060 12GB, 4070) | Q3_K_S / Q3_K_M | Q4_K_M (GGUF) | Widest compatibility, most visible quality loss — community reports call this "lower quality, wider compatibility" |
| 16GB (e.g. RTX 4080) | Q4_0 / Q4_K_S / Q4_K_M | Q4_K_M (GGUF) | The general community recommendation — balance of quality and fit |
| 24GB (e.g. RTX 4090, 3090) | Q5_K_M or the non-quantized FP8/NVFP4 path | NVFP4/AWQ (non-GGUF) | Closest to full quality — this is the path we ran our own 50-clip quality test on. See ComfyUI setup |
These are file-size-based fit estimates, not benchmarked runtimes — we haven't independently measured runtime/VRAM peaks for every GGUF combination the way we did for the full-precision RTX 4090 path. If you need verified runtime and VRAM numbers, start from the tested RTX 4090 data and scale down conservatively.
If your card doesn't clear even the 12GB tier, quantization won't get you there — at that point MiniMax H3's hosted generator is the more realistic option.
Setup Steps
- Complete the base ComfyUI install (0.30.0+, dedicated environment).
- Install a GGUF loader custom node if your ComfyUI setup doesn't already include one (search "GGUF" in the ComfyUI Manager node browser).
- Download your chosen UNet quant, text encoder, and VAE files from the community GGUF repositories and place them in the directories your GGUF loader node expects.
- Load the FL2VA or Ref2VA workflow depending on your input type, point each loader at the GGUF/quantized files, and queue a short test generation before a long one.
Quality Tradeoffs of Going Smaller
Quantization doesn't fix anything — it only compresses what's already there. Our own testing on the full-precision FP8/NVFP4 path (not even quantized down to GGUF) already showed real limitations: dialogue audio degrading into repeated syllables, inconsistent sports physics, occasional extra fingers or malformed objects. Dropping to Q3 or Q4 GGUF will not improve on that baseline — community reports describe Q3 as noticeably softer/less coherent than Q4, which is why Q4 is the more commonly recommended starting point rather than the smallest available file.
Full test data and examples: Real Output Quality.
Worth noting: a quantized local build trades quality for VRAM headroom, while MiniMax H3 online always runs at full precision — the two aren't quality-equivalent options, just different tradeoffs.
Troubleshooting
| Problem | Fix |
|---|---|
| GGUF loader node missing | Install a GGUF loader custom node via ComfyUI Manager — it's not built into base ComfyUI |
| Model loads but output is visibly worse than expected | Check you're not pairing a low UNet quant with a mismatched text encoder — try the same quant tier for both |
| Out-of-memory even on a quantized build | Verify offloading is enabled; also check the VAE and text encoder are correctly separated from the UNet's VRAM allocation, not double-loaded |
| Can't find official documentation for an error | Expected — GGUF builds are community-maintained, not part of MiniMax's or Comfy-Org's documented workflow. Check the specific Hugging Face repo's community/discussion tab |
FAQ
What's the best GGUF quant level for MiniMax H3?
Q4 (Q4_K_M or Q4_K_S) is the community's general recommendation — a practical balance between file size and output quality. Q3 fits more GPUs but is noticeably softer; Q5 is closer to full precision but needs more VRAM.
Can MiniMax H3 GGUF run on 8GB VRAM?
The smallest listed UNet quant (Q3_K_S/M) alone is 15.6GB, which exceeds 8GB even before adding a text encoder and VAE. An 8GB card will need aggressive CPU offloading and reduced resolution/frame count, and should expect a meaningful speed and quality hit. There's no verified 8GB benchmark in this guide — treat it as experimental at that tier.
Is MiniMax H3 GGUF the same as the official Comfy-Org build?
No. The official Comfy-Org build (covered in the ComfyUI guide) uses pruning and int8 quantization to reach ~42.5GB and is actively maintained by Comfy-Org. GGUF conversions are separate, community-maintained files.
Do I need both the UNet and text encoder in GGUF format?
No — you can mix a GGUF UNet with a non-GGUF (safetensors) text encoder or vice versa, as long as your workflow's loader nodes match each file type. Matching quantization tiers across both is the simpler starting point.
Don't Want to Manage Quantization Tradeoffs?
MiniMax H3 online runs full precision at 2K in your browser — no quant level to choose, no VRAM math. Free starter credits to try it.