MiniMax H3 Local Setup: Run the Open Video Model in ComfyUI

Short answer: MiniMax H3 runs locally today. Update ComfyUI to 0.30.0, download four files from the Comfy-Org/MiniMax-H3 repack — the 21GB pruned INT8 diffusion model, 15.7GB NVFP4 text encoder, 5.21GB video VAE, and 605MB audio VAE (~42.5GB total, matching Comfy's own published figure) — and open the built-in MiniMax H3 template. The ComfyUI team says dynamic offloading runs it on a GPU "like the RTX 3060"; a 24GB card is the comfortable tier. There is no official VRAM matrix — every per-GPU number you see online right now is community-reported. And one thing the launch posts blur: local output is 768p; the "2K" stage is a hosted API, not part of the open weights.

H3 is the model that made multiple Hugging Face repos trend simultaneously in its first week: the official 33B release, Comfy's quantized repack, and community GGUF packs that pulled 84,340 and ~40,000 downloads within days of the August 3 release. The reason is simple — it is an open-weights video model that generates stereo audio in the same pass as the video, up to 15-second clips. The established open video pipelines — Hunyuan Video, Wan — generate silent clips and leave the soundtrack to you. It is the same day-0 wave we saw with FLUX.2: official repack, quants, GGUFs, even an MLX port, all live inside a week. This guide covers the exact setup that works as of August 2026, what the file sizes actually let you run, and where the sharp edges are.

---

What MiniMax H3 Is (and What "Open" Means Here) {#what-is-minimax-h3}

H3 is a 33B-parameter omni-modal video model — video and stereo audio from one generation pass — released with open weights on August 3, 2026, with native ComfyUI support on day 0.

The verified spec sheet, from the official model card (MiniMaxAI/MiniMax-H3 on Hugging Face) and the ComfyUI announcement:

• Architecture: 33B-parameter dense, single-stream transformer ("H3-Omni-Transformer"), with roughly 13B parameters in AdaLN-related branches — a detail that matters later, because it is what makes the "pruned" checkpoints possible.
• Three modules: H3-Context-IR (input preprocessing), H3-Base (generation), and H3-Regenerate-2K (the upscaling stage — see the next section before you get excited).
• Output: 4-15 second clips at 24fps on a native 768p canvas (shorter side = 768px).
• Audio: 32kHz stereo, generated natively in the same pass, with dialogue support in 11 languages per comfyui-wiki's coverage.
• Text understanding: the full pretrained weights of Qwen3-VL-32B ride along as the text encoder — H3 effectively ships with a second large model whose job is understanding your prompt.
• Two open generation modes: FL2VA (text-to-video with optional first/last-frame conditioning — this covers classic T2V and I2V) and Ref2VA (reference-to-video, conditioning on up to 9 images, 3 videos, and 3 audio clips per comfyui-wiki).
• License: "MiniMax H3 Community License Agreement" — open weights, not Apache. Read it before commercial use.
• Inference support: ComfyUI (day 0), plus SGLang, vLLM, and Diffusers for server deployments.

The headline from Comfy's engineering side: full-precision H3 is a 123.6GB memory footprint, and their shipped quantizations cut that by 66% to 42.5GB with the smallest variants — which is exactly what the four recommended files below sum to. The weights use what Comfy calls an int8 "convrot" quantization plus custom kernels that reduce peak VRAM during inference.

One more phrase worth decoding: the "pruned" checkpoints. Per comfyui-wiki's coverage, the pruned files are about 40% smaller than the standard INT8 files because the AdaLN modulation curves — that ~13B-parameter block — are replaced with precomputed tables. That is why the recommended diffusion file is 21GB instead of 34GB.

---

The 2K Asterisk {#the-2k-asterisk}

Local H3 output tops out at a 768px short edge — about 1344x768 at 16:9. The "2K" in the marketing comes from H3-Regenerate-2K, an upscaling module that is a hosted API, not an open checkpoint.

This deserves its own section because the launch headlines (including ComfyUI's own: "Open Weights, Native Audio, and 2K Video") blur it. Only the H3-Base checkpoints — FL2VA and Ref2VA — are in the open-weight release. Comfyui-wiki's model page states the Regenerate-2K module "remains hosted APIs," and community documentation is blunt about it: local base output is 768p; full 2K uses the API-assisted path. Nobody has published the 2K stage's hardware cost, because nobody outside MiniMax runs it.

Practical read: what you can run on your own GPU is a 768p, 24fps, up-to-15-second video generator with synchronized stereo sound. That is still a genuinely new local capability — the mature open video pipelines (Hunyuan, Wan) leave you to add sound afterwards. But if your requirement is "2K video, fully offline," H3 does not deliver that today. You can chain a generic video upscaler after it; just know that is your pipeline, not H3's.

---

Every File and Where It Goes {#download-map}

You need exactly four files for text-to-video and image-to-video: one diffusion model, one text encoder, two VAEs — ~42.5GB total, all from the Comfy-Org/MiniMax-H3 repository on Hugging Face. Reference-to-video swaps in a different diffusion model and reuses everything else.

File names and folder placement are from the official ComfyUI documentation (docs.comfy.org); sizes are as listed in the Comfy-Org repo's file browser as of late August 2026:

For reference-to-video (consistent characters/objects across a clip), replace the first file with minimax_h3_ref2va_pruned_int8_convrot.safetensors (also 21GB) — same folder, and the text encoder and VAEs stay the same.

Two details worth noticing. First, yes — the text encoder is a 32B Qwen3-VL, quantized to NVFP4 AWQ. Second, the audio VAE is a separate file, which is what "audio in the same pass" looks like in practice: both VAEs sit in the same folder and the workflow decodes video and stereo audio together. A missing audio VAE is the classic silent-output failure.

If you want to trade disk and VRAM for quality, the repo also carries heavier tiers (sizes from the same file browser): the pruned FP8 at 21GB, unpruned INT8 at 34GB, pruned BF16 at 40.2GB, full BF16 at 66.3GB, and the text encoder at 27.1GB (INT8) or 51.5GB (BF16). Start with the pruned INT8 set — it is what the official workflow templates expect.

---

Step-by-Step ComfyUI Setup {#comfyui-setup}

The whole install is: update ComfyUI to 0.30.0 or later, open the template library, pick a MiniMax H3 workflow, and let ComfyUI prompt-download the models. No custom nodes required — support is native.

Step 1 — Update ComfyUI to 0.30.0+. Desktop app: update from the menu. Manual install: git pull in your ComfyUI folder, then pip install -r requirements.txt, and restart. Version 0.30.0 is the hard floor — the H3 nodes do not exist before it. If you are new to ComfyUI entirely, set it up first with our ComfyUI complete guide and come back.

Step 2 — Open a template. Workflow menu → Browse Templates → Video. Three official H3 templates ship with 0.30:

Step 3 — Download the models. Opening a template prompts you to download each missing file. Accept, or download manually from Comfy-Org/MiniMax-H3 into the folders in the table above. With the Hugging Face CLI, one command fetches the four-file set — the repo's folders mirror ComfyUI's model folders: hf download Comfy-Org/MiniMax-H3 --include "diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors" "text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors" "vae/*" --local-dir ComfyUI/models. On a manual download, double-check that both VAEs landed in models/vae.

Step 4 — Optional but recommended: Sage Attention. The official docs say you can "roughly double the generation speed with Sage Attention, with minimal quality loss." Note the install is not a plain pip package name: you download a prebuilt wheel matching your PyTorch and CUDA versions, then pip install that wheel file — the docs.comfy.org tutorial links the wheels.

Step 5 — Generate. Write a prompt, queue it. Keep the resolution defaults on your first run: H3's native canvas is a 768px short edge, capped at 768x1344, with dimensions rounded to a multiple of 32 (per docs.comfy.org — about 1.0 megapixel, so 16:9 lands at roughly 1344x768). The templates offer aspect presets like 16:9, 9:16, and 1:1. Duration runs 4-15 seconds at 24fps, with frame counts following a 17-frame-block grid (17k+5) that the template snaps for you. The audio comes out of the same queue job — no second pass, no separate node graph.

If your card is on the small side, do first runs at short durations (4-5 seconds) before attempting anything ambitious. Longer clips scale the latent memory footprint, and on an offloading setup that is the difference between slow and out-of-memory. The first run is always slowest — the 32B text encoder has to load and encode before the diffusion model takes over.

Advanced path — full official weights. If you have multi-GPU hardware and want the unquantized checkpoints for SGLang or vLLM (the official card's SGLang example uses 4 GPUs), the official repo download is hf download MiniMaxAI/MiniMax-H3 --include "model_index.json" "modular_model_index.json" "FL2VA/*". That is server territory — for a single consumer GPU, the ComfyUI path above is the one that matters.

---

VRAM: What Is Actually Known {#vram-requirements}

There is no official VRAM matrix for MiniMax H3 — not from MiniMax, not from Comfy. The one load-bearing published claim comes from the ComfyUI team's announcement: int8 convrot quantization, custom kernels, and dynamic VRAM offloading enable H3 to run locally on a GPU "like the RTX 3060" — a 12GB card. Everything more specific is community-reported, so treat per-GPU numbers (ours included) as reasoning, not benchmarks.

The most concrete community guidance comes from the Abiray quant card on Hugging Face (the INT4/INT8 convrot pack, ~43K downloads in week one), which maps its own files like this:

And here is what the official file sizes let you reason honestly:

• The pruned INT8 diffusion model alone is 21GB. It cannot fully reside in 16GB or 12GB of VRAM. On those cards, ComfyUI's dynamic offloading is doing real work every step — shuttling weights between system RAM and VRAM — which costs generation speed. It runs; it does not run fast.
• 24GB is the comfortable tier. The diffusion model fits in VRAM with room for latents on a used RTX 3090 or better — our RTX 3090 local AI guide makes the case for that card as the price-per-VRAM pick, and current street pricing (see what the memory shortage did to GPU prices) has only strengthened it. The 32B text encoder still gets offloaded after encoding your prompt, which is normal and cheap — it runs once per prompt, not per step.
• System RAM is the silent requirement. Offloaded weights have to live somewhere. With ~42.5GB of model files in play, 32GB of system RAM will be tight alongside the OS and ComfyUI itself; 64GB is the comfortable configuration for the offload path. That is our arithmetic, not a published spec — nobody has published one.
• On a 12GB card like the RTX 3060, you are inside Comfy's own stated envelope, but expect the slowest path: heavy per-step offloading plus the text encoder swap. If that is your card, our RTX 3060 model picks covers what else it runs well, and our low-VRAM text-to-video guide covers lighter video options if H3's speed on your hardware disappoints.

We have not benchmarked H3 on our own hardware yet — generation-time numbers here would be invented, so there are none. When credible per-GPU timing data lands (or we test a 24GB run ourselves), this section gets updated.

---

The GGUF Quant Ecosystem {#gguf-ecosystem}

Days after release, H3 already has a bigger quant ecosystem than most video models get in months — 84,340 downloads on the largest GGUF pack alone. Sizes below are as listed on each repo's model card in August 2026; download counts move daily.

There is even an 8-bit MLX conversion for Apple Silicon already on the Hub. A few honest notes on this table, though. The GGUF Q4_K_M files (19.9GB) are essentially the same size as Comfy's pruned INT8 safetensors (21GB) — GGUF is not automatically the smaller path here, and the official ComfyUI templates are built around the safetensors repack, so GGUF only earns its complexity if you are chasing sub-Q4 quants (realrebelai's Q2_K at 8.49GB is the "it technically fits" tier for small cards) or working inside a GGUF-based tool. The GGUF route also needs a GGUF loader node and, per the realrebelai card, still requires both VAE files from the Comfy-Org repack. Video models degrade visibly at 2-3 bit — nobody has published side-by-side comparisons yet, so treat aggressive quants as preview tools, not final-render paths. And none of these community packs publish VRAM requirements either — the no-official-matrix problem runs through the whole ecosystem.

---

H3 vs Hunyuan vs Wan {#vs-hunyuan-wan}

H3's pitch against the established open video models is audio and clip length: stereo sound in the same pass and up to 15 seconds, where the incumbents generate silent clips. Maturity runs the other way — Hunyuan and Wan have months of community LoRAs, tuned workflows, and well-understood hardware behavior; H3 is days old. No reputable quality benchmark between the three exists yet, so anyone giving you a ranked verdict this month is guessing.

Where each fits, based on what is verifiable today:

• Hunyuan Video remains the most battle-tested open video pipeline in ComfyUI, with a deep bench of community fine-tunes and known-good low-VRAM recipes. Silent output — audio is your problem afterwards.
• Wan is the other mature line, with strong image-to-video behavior and a big LoRA scene. Also silent.
• MiniMax H3 generates the soundtrack with the picture — 32kHz stereo, with dialogue in 11 languages per comfyui-wiki — and its Ref2VA mode conditions on up to 9 images, 3 videos and 3 audio clips, a richer reference interface than either older model ships natively. The trade: a young ecosystem, a community license rather than a permissive one, hardware behavior the community is still mapping, and no LoRA library to speak of yet.

Practical advice: if you have a working Hunyuan or Wan pipeline, run H3 in parallel for a week on prompts where audio matters before migrating anything. If you are starting from zero, H3 is the more future-facing first install — and the fallback costs you nothing, since all three run in the same ComfyUI. For the wider landscape, our local AI video generation overview compares the full field.

---

Honest Limitations {#limitations}

The rough edges, so you hit none of them blind:

1. "2K" needs an asterisk — a big one. Native generation is a 768p canvas; 2K comes from the H3-Regenerate-2K module, which is a hosted API, not open weights. See the asterisk section.
2. No VRAM matrix, anywhere. The RTX 3060 claim from Comfy is the entire official hardware guidance. Every tier list circulating (including our arithmetic above) is inference from file sizes and community model cards, not measurement.
3. It is a ~42.5GB download for the smallest sensible set, and heavier tiers reach well past 100GB. Budget disk and bandwidth accordingly.
4. Speed is unquantified. Neither the announcement nor the docs publish generation times, and we have not benchmarked it ourselves. On offloading setups especially, assume slow until proven otherwise.
5. Community license, not Apache. Free to download and run locally; commercial terms live in the MiniMax H3 Community License Agreement on the official repo. Read it — the license text is the only thing that counts.
6. The ecosystem is days old. Quant packs are iterating hourly, best-practice settings are unsettled, and early GGUFs may be re-uploaded with fixes. Expect this page's ecosystem table to age fastest; the core Comfy-Org setup is the stable path. If a download 404s, check the repo's file browser before assuming this guide is wrong.

---

Verdict {#verdict}

Install it if you have 24GB of VRAM or the patience for offloading — H3 is the first open-weights video model where the clip comes out finished, sound included.

The setup is genuinely easy by new-model-wave standards: native day-0 ComfyUI support, no custom nodes, four files, official templates. The 42.5GB pruned INT8 set is the right starting point for everyone; ignore the heavier tiers until you have a reason. On 24GB the experience should be comfortable; on 12-16GB it runs inside Comfy's stated envelope but offloading will tax your patience, and the low-VRAM video alternatives remain real options. Just go in knowing the local ceiling is 768p — the 2K stage stayed behind the API.

What would change this verdict: per-GPU benchmarks (either direction), the 2K stage shipping as open weights, or license clarifications. This page gets a refresh pass as the quant ecosystem settles — the file names above are the stable core; the ecosystem table is the moving part.

---

Sources {#sources}

Everything above is drawn from these, checked in August 2026:

• MiniMaxAI/MiniMax-H3 — official model card: architecture, output specs, audio, modes, license, SGLang example
• ComfyUI blog: MiniMax H3 Day-0 Support (Aug 3, 2026) — 0.30.0 requirement, 123.6GB→42.5GB quantization figures, RTX 3060 claim
• docs.comfy.org MiniMax H3 tutorial — exact file names, folder placement, canvas limits, template names, Sage Attention note
• Comfy-Org/MiniMax-H3 — the repack this guide installs; file sizes from the repo's file browser
• Abiray/MiniMax-H3-GGUF, realrebelai/MiniMax-H3_GGUFs, Abiray convrot pack — community quant sizes, VRAM guidance, and download counts as listed in August 2026
• comfyui-wiki MiniMax model page — 33.1B figure, Ref2VA limits, pruned-checkpoint explanation, Regenerate-2K hosted-API status

Download counts and file listings are as observed in August 2026 and will drift.

---

FAQ {#faq}