MiniMax H3 hardware requirements: VRAM, GPU and RAM
- Page updated
- Sources checked
- Recipes as published by SGLang, diffusers and vLLM; times only as measured in the SGLang cookbook
- File sizes from Hugging Face, read October 12, 2026
- Jump to the checker ↓
MiniMax H3 is MiniMax's open-weight video model: it generates up to 15 seconds of video with native stereo audio in one pass, from text, first and last frames, or image, video and audio references. The open release is the H3-Base generator: a 33B-parameter diffusion transformer plus a Qwen3-VL-32B text encoder, at a 768-pixel short edge and 24 fps. Its license gives August 2, 2026 as the release date.
Short answer: the BF16 weights for one task are 144 GB, so no consumer GPU holds them: every published consumer recipe streams the weights from system RAM, or NVMe when RAM is short. The smallest published setup is an NVIDIA GPU with 12 GB of VRAM and 32 GB of RAM plus an NVMe drive at 480P (SGLang, run with the memory capped; a real 32 GB PC will be slower). Keeping every weight on the GPU takes 4× H100 80 GB (SGLang), two 80 GB cards, or two 48 GB cards with int8 (diffusers), or one 192 GB AMD MI300X. We found no published Mac run. License: MiniMax's open-weights license does not cover the US, the EU, the UK or South Korea.
Can my hardware run MiniMax H3?
Open in a full page ↗Loading private checker…
- Developer
- MiniMax Official
- Params
- 33B-parameter dense Official
- Output
- 768-pixel short edge (1344×768 at 16:9), 24 fps, 4–15 seconds Official
- License
- MiniMax's open-weights license does not cover the US, the EU, the UK or South Korea Official
- SGLang
- 12 GB of VRAM and 32 GB of RAM plus an NVMe drive at 480P (SGLang, run with the memory capped; a real 32 GB PC will be slower) Official
- Diffusers
- two 48 GB cards with int8 (diffusers) Official
- stable-diffusion.cpp
- Unsloth's GGUF files run in stable-diffusion.cpp Community
Choose task files and a local or hosted route
Local H3-Base: choose FL2VA for text/first-last-frame generation, or Ref2VA for image/video/audio references. Use the complete single-task download command in the checker: it includes that task’s transformer, text encoder, video/audio VAEs, processor, tokenizer and task index, plus the root repository index. The component links and GB figures are weight-only references. Do not download the repository’s duplicate runtime layouts or both tasks unnecessarily. The checker downloads the original task layout; for ComfyUI choose that task’s files from its own guide instead.
Full 2K workflow: H3-Context-IR prompt processing and H3-Regenerate-2K are hosted modules. The open generator can use a direct prompt locally, but does not reproduce the full hosted pipeline offline. No quantity of local VRAM removes this API dependency.
Longer clips, larger canvases and additional references increase visual/audio tokens, attention and VAE working memory. Recipe matches below are memory/class matches for the source’s stated shape, not a promise for every 4–15 second or multi-reference request. Start with the documented canvas and step count, then retune offload and VAE decoding. Ref2VA has no transferable FL2VA timing. We do not use chat KV-cache math to predict video generation peaks.
ComfyUI task templates and component files · Community GGUF files for stable-diffusion.cpp (no verified GGUF memory threshold)
How much VRAM does MiniMax H3 need?
More than any consumer card has, if everything stays on the GPU. File sizes as Hugging Face lists them (decimal GB, read October 12, 2026). One task needs one transformer (FL2VA for text-to-video and first/last frame, Ref2VA for references), the shared text encoder and the two VAEs.
| Component and format | File size | Used by | Source |
|---|---|---|---|
| Transformer (FL2VA or Ref2VA), BF16 | 66.3 GB each | SGLang, vLLM, diffusers, ComfyUI | MiniMax |
| Text encoder (Qwen3-VL-32B), BF16 | 66.7 GB | SGLang, vLLM, diffusers | MiniMax |
| Video VAE + audio VAE | 10.4 + 0.6 GB | all | MiniMax |
| One task, official BF16 | 144.0 GB | all | MiniMax |
| Transformer, pruned (AdaLN branches replaced), BF16 | 40.2 GB | ComfyUI | Comfy-Org |
| Transformer, int8 (ConvRot) | 34.0 GB | ComfyUI | Comfy-Org |
| Transformer, pruned int8 (ConvRot), the ComfyUI templates' default | 21.0 GB | ComfyUI | Comfy-Org |
| Transformer, pruned FP8 / pruned W6A8 (W6A8 needs ComfyUI 0.38.0 or later, per the ComfyUI guide, read October 19, 2026) | 21.0 / 16.0 GB | ComfyUI | Comfy-Org |
| Text encoder for ComfyUI: BF16 / int8 / NVFP4-AWQ | 51.5 / 27.1 / 15.7 GB | ComfyUI | Comfy-Org |
| Video VAE for ComfyUI, FP16 | 5.2 GB | ComfyUI, stable-diffusion.cpp | Comfy-Org |
| Transformer GGUF, pruned: Q2_K to Q8_0 | 6.7 to 21.4 GB | stable-diffusion.cpp | Unsloth |
| Text encoder GGUF: Q2_K_M / Q4_K_M | 13.1 / 18.2 GB | stable-diffusion.cpp | Unsloth |
The official repository holds both the original checkpoint folders and a diffusers layout, 498.5 GB in all: download only what your runtime needs. SGLang's cookbook counts its BF16 path at about 108 GB of weights (61.73 GB of transformer and 46.18 GB of text encoder; its 61.73 is the 66.3 GB file above in GiB, though the cookbook writes GB); vLLM's recipe lists a 51.5 GB text encoder cut at layer 50; diffusers counts 61.7 GB and 62.1 GB (the same files as above, in GiB). The 13B parameters in the transformer's AdaLN branches are not needed for inference (MiniMax's model card); the pruned builds replace them with a small curve table. The ComfyUI path SGLang's cookbook describes for 12 GB cards uses the pruned int8 transformer and the NVFP4-AWQ text encoder: different weights from the official BF16 files. Pruned and quantized files are not MiniMax's.
What hardware can run MiniMax H3?
One published recipe per hardware tier, smallest first; this is not every recipe. Not listed here: SGLang's default AMD setup (8× MI300X or MI355X, Ulysses8) and its 2× / 4× AMD scaling runs, its alternative H100 (TP4, FSDP) and H200 (FSDP) layouts, its B200, B300, GB300 and Ascend recipes, and vLLM-Omni's RTX PRO 5000 and 4× MI300X / 4× MI355X profiles; see the sources. Each is the source's own setup; we have not run them.
| Hardware | Runtime and recipe | Evidence | Source |
|---|---|---|---|
| 1 NVIDIA GPU, 12 GB + 32 GB RAM + NVMe | SGLang Recipe A: transformer, text encoder and VAE streamed from the checkpoint file | lab run (12 GiB cap, simulated 32 GB host) | SGLang cookbook |
| 1 NVIDIA GPU, about 12 GB | ComfyUI, unpruned bf16 files: peaked at 12.1–12.3 GiB under a 12 GiB cap; on a real 60 GB desktop its default command was killed while loading and needed --fast-disk; a real 32 GB host is untested (not matched by the checker) | lab run (simulated 32–64 GB host) | SGLang cookbook (SGLang's test of ComfyUI) |
| 1 NVIDIA GPU, 12–16 GB + about 75 GB in RAM | diffusers: int8 transformer and text encoder, blocks and VAE offloaded, small canvas (960×544) | documented, no timing | diffusers docs |
| 1 NVIDIA GPU, 16 GB + about 117 GB pinned in RAM | SGLang Recipe B: 4 transformer layers resident, the rest pinned in RAM (the cookbook elsewhere says about 96 GB of host RAM is enough for this flag; its run pinned 116.7 GB) | lab run (16 GiB cap) | SGLang cookbook |
| 1 NVIDIA GPU, 24–32 GB + RAM about 75 GB, RigCheck assumption from the 12–16 GB variant | diffusers: int8 transformer and text encoder, transformer blocks streamed from RAM | documented, no timing | diffusers docs |
| 1× RTX 4090 D (24 GB), not a standard RTX 4090 | SGLang: transformer and text encoder streamed layer by layer, BF16 or convrot_int8; GPU peak about 18 GB | measured (host RAM not stated) | SGLang cookbook |
| 1× RTX 5090 (32 GB) + 60 GB RAM + 8 GB swap + NVMe | SGLang: 14 transformer layers resident, BF16 | measured on a physical desktop | SGLang cookbook |
| 2× RTX 5090 (32 GB) + 384 GiB-class host | SGLang TP2 with layerwise offload, 20 transformer blocks resident | measured | SGLang cookbook |
| 2× RTX 4090 or 2× RTX 5090 + 384 GiB-class host | vLLM-Omni TP2 with distributed layerwise offload: 12 resident layers and a 1024×576 starting shape on 4090s (requests must pass aspect_ratio=16:9), 20 layers at 1344×768 on 5090s | documented, no timing | vLLM recipe |
| 1 NVIDIA GPU, 80 GB | diffusers: BF16 with automatic CPU offload | documented, no timing | diffusers docs |
| NVIDIA DGX Spark (128 GB unified) | SGLang with no extra flags (automatic offload) | measured | SGLang cookbook |
| 2 NVIDIA GPUs, 48 GB each / 80 GB each | diffusers: pipeline split across the cards, int8 / BF16, nothing offloaded | documented, no timing | diffusers docs |
| 4× H100 80 GB (also measured on 4× H200: 78.3–85.5 s per 1344×768, 5-second, 50-step request, 63.5 GB peak per GPU) | SGLang, all weights resident (TP2 + Ulysses2), 66.0 GB peak per GPU | measured | SGLang cookbook |
| 4× H200 141 GB | SGLang, all weights resident (Ulysses4), 94.3 GB peak per GPU | measured | SGLang cookbook |
| 1× AMD Instinct MI300X (192 GB) or MI355X (288 GB) | SGLang, all weights resident, 137.6–137.7 GB peak | measured | SGLang cookbook |
On consumer hardware, the SGLang cookbook says, "the binding question is not which card you have but how much host RAM sits behind it." With little RAM the weights are re-read from the drive on every step: it calls an NVMe drive a requirement (a PCIe 4.0 drive keeps up, a PCIe 3.0 drive becomes the bottleneck) and a SATA SSD not usable for this model. Its lab runs kept the whole checkpoint in the page cache of a 2 TB machine, so a real 32 GB PC should be expected to be slower than they are. On a real 60 GB desktop, ComfyUI's default command was killed for lack of memory while loading and needed --fast-disk (SGLang's was too, until a fix to how it pins memory). These recipes generate at 480P or 768P; MiniMax's 2K output is a separate step that is not in the open release.
vLLM's recipe (read October 22, 2026) also lists single-card configurations for FastH3, FastVideo's post-trained versions of H3 that generate in four or eight steps, for a prompt plus a reference image: the NVFP4 FastH3-Omni build on an RTX 5090 (32 GB), a DGX Spark (128 GB) or an RTX PRO 6000 Blackwell (96 GB), and the eight-step BF16 Omni model, with eligible weights converted to FP8 while loading, on an RTX 4090 (24 GB). These are different weights from MiniMax's (published under the same MiniMax H3 Community License), they need the source branch of vLLM-Omni pull request #9167, and the recipe calls the single-card profiles "configuration guidance" that "this documentation change does not independently qualify ... with GPU inference"; it states no host RAM for them. The checker does not match them.
How fast is MiniMax H3 locally?
Each row is a published measurement with its own setup; we do not convert one setup's time into another's. All are text-to-video with audio from the FL2VA checkpoint, except the DGX Spark run, whose task the cookbook does not state.
| Hardware | Setup and clip | Time | Source |
|---|---|---|---|
| 1× RTX 5090 (32 GB), Ryzen 9 9950X, 60 GB RAM, 8 GB swap, PCIe 5.0 NVMe | SGLang, BF16, 14 layers resident; 864×480, 124 frames, 20 steps | 112 s per request (5.1 s per step); ComfyUI with --fast-disk --cache-none: 141–146 s | SGLang cookbook |
| 1× RTX 4090 D (24 GB), host RAM not stated | SGLang, layerwise offload; 1344×768, 107 frames, 20 steps | 405.6 s at BF16; 303.3 s with convrot_int8 (faster approximate attention: 163.8–223.9 s) | SGLang cookbook |
| 1× RTX 4090 D (24 GB), host RAM not stated | SGLang, same, 50 steps | 1,008.6 s at BF16; 718.5 s with int8; 285.3 s with int8 + step skipping (Spectrum) | SGLang cookbook |
| 2× RTX 5090 (32 GB), 377 GiB host | SGLang TP2 + layerwise offload; 1344×768, 5 seconds, 50 steps | 559.7 s | SGLang cookbook |
| NVIDIA DGX Spark | SGLang, automatic offload; 480P | about 12 min per warm request; a text-encoding stage of about 5.5 min per request; about 12 min to load | SGLang cookbook |
| 4× H200 | SGLang, all resident; 1344×768, 5 seconds, 50 steps | 74.4 s with the warmup set to 1344×768; 84.1 s with the default warmup | SGLang cookbook |
| 1× AMD MI300X / MI355X | SGLang, all resident; 1344×768, 209 frames, 50 steps | 978.1 s / 288.8 s of denoising, plus 36.0 s / 24.0 s of decoding | SGLang cookbook |
The SGLang cookbook's lab runs on 12 and 16 GB (memory capped on an unnamed lab GPU; host RAM simulated for the 12 GB runs) are not in this table, because their times are not a 12 or 16 GB card's times. For a 4090 on a 32 GB PC with a PCIe 4.0 drive, the cookbook derives about 8.5 s per 480P step (SGLang estimate) but says that machine has not been re-measured. The 4090 rows are from an RTX 4090 D, not a standard RTX 4090. Approximate attention and step skipping trade quality for speed (the cookbook lists PSNR for most of these rows, against BF16 or against its int8 run); ComfyUI's turbo LoRA cuts the steps to 8 or 4.
Measured MiniMax H3 on your own hardware, or tried and it failed? Send us the numbers: paste the benchmark output or log into the form (or email it). After checking it we add it to this page, labeled as a community report and shared under CC BY 4.0.
MiniMax H3 specs
| Transformer | 33B-parameter dense, single-stream "Omni Transformer" that predicts video and audio together; about 13B of the parameters are AdaLN branches that inference-only deployments need not load Model card |
|---|---|
| Text encoder | Qwen3-VL-32B, read at its 50th layer; also encodes image and video inputs Model card |
| VAEs | Video VAE with 16× spatial and 4× temporal compression; audio VAE at 32 kHz stereo Model card |
| Checkpoints | FL2VA (text-to-video, first / last frame) and Ref2VA (up to 9 images, 3 video and 3 audio references), BF16, guidance-distilled (one forward pass per step) Model card |
| Output | 768-pixel short edge (1344×768 at 16:9), 24 fps, 4–15 seconds (diffusers accepts 5–15), 32 kHz stereo audio; 2K needs MiniMax's regeneration step, API-only for now Model card |
| Not in the open release | H3-Context-IR (the prompt-processing system MiniMax "strongly recommends") is API-only; H3-Regenerate-2K is "not yet open-sourced" and MiniMax says it will release it; sparse attention is to be released later Model card |
| Runtimes | MiniMax names SGLang, vLLM (vLLM-Omni), diffusers and ComfyUI; Unsloth's GGUF files run in stable-diffusion.cpp (checked October 12, 2026) |
MiniMax H3 license
The MiniMax H3 Community License grants use, modification and redistribution only within its "Applicable Territory": worldwide except the European Union, the United Kingdom, South Korea and the United States. MiniMax's license Q&A says the exclusion reflects unsettled rules for video models, that organizations there can apply for a license, and that it means "not yet", not "not ever". Inside the territory, commercial products must display "MiniMax H3", and those with more than US$20 million in yearly revenue need MiniMax's written authorization. MiniMax claims no rights over the videos you generate, but the license also bars using or displaying them outside the territory, using them to improve other AI models, and (in its acceptable-use policy) posting machine-generated content publicly without disclosing it. ComfyUI's guide says commercial use of locally generated videos needs a MiniMax commercial license, sold through Comfy; the license text itself requires MiniMax's authorization only above US$20 million in yearly revenue. RigCheck is not a lawyer: read the license before you download.
Common setups
The checker's own answer for 8 common setups (graphics cards with 32 or 64 GB of system RAM, then Macs), in the finder's quick mode (local H3-Base FL2VA recipes, assuming an NVMe drive). Answers are published recipe matches, not measured setups; "Unknown" means the checker has no route or source for that hardware. Your own setup: the checker.
| Setup | Answer |
|---|---|
| GeForce RTX 3060 (12 GB) + 32 GB RAM | ! Hardware memory matches a published video recipe; exact clip peak unverified (published recipe match) Matching recipes: SGLang Recipe A (lab): one card, DiT, text encoder and VAE streamed from the checkpoint file on an NVMe drive (Recipe A), BF16; measured at 864×480 (at the native 768P the cookbook says to use video_vae=24 if the decode runs out of memory, not measured); lab run with VRAM capped at 12 GiB and a simulated 32 GB host: shows the memory fits, not your card's speed; a real 32 GB machine re-reads the weights from disk on every step. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
| GeForce RTX 4060 Ti (16 GB) + 32 GB RAM | ! Hardware memory matches a published video recipe; exact clip peak unverified (published recipe match) Matching recipes: SGLang Recipe A (lab): one card, DiT, text encoder and VAE streamed from the checkpoint file on an NVMe drive (Recipe A), BF16; measured at 864×480 (at the native 768P the cookbook says to use video_vae=24 if the decode runs out of memory, not measured); lab run with VRAM capped at 12 GiB and a simulated 32 GB host: shows the memory fits, not your card's speed; a real 32 GB machine re-reads the weights from disk on every step. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
| GeForce RTX 3090 / 3090 Ti (24 GB) + 64 GB RAM | ! Hardware memory matches a published video recipe; exact clip peak unverified (published recipe match) Matching recipes: SGLang, one 24 GB card (measured): one card, DiT and text encoder streamed layer by layer; GPU peak about 18 GB; RTX 4090 D: 1344×768, 107 frames, 20 steps in 405.6 s at BF16, 303.3 s with convrot_int8 (host RAM not stated for this run; we require the 32 GB of the cookbook's smallest recipe (RigCheck assumption); a 4090 on a 32 GB host has not been measured) | SGLang Recipe A (lab): one card, DiT, text encoder and VAE streamed from the checkpoint file on an NVMe drive (Recipe A), BF16; measured at 864×480 (at the native 768P the cookbook says to use video_vae=24 if the decode runs out of memory, not measured); lab run with VRAM capped at 12 GiB and a simulated 32 GB host: shows the memory fits, not your card's speed; a real 32 GB machine re-reads the weights from disk on every step. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
| GeForce RTX 5090 (32 GB) + 64 GB RAM | ! Hardware memory matches a published video recipe; exact clip peak unverified (published recipe match) Matching recipes: SGLang, one 24 GB card (measured): one card, DiT and text encoder streamed layer by layer; GPU peak about 18 GB; RTX 4090 D: 1344×768, 107 frames, 20 steps in 405.6 s at BF16, 303.3 s with convrot_int8 (host RAM not stated for this run; we require the 32 GB of the cookbook's smallest recipe (RigCheck assumption); a 4090 on a 32 GB host has not been measured) | SGLang Recipe A (lab): one card, DiT, text encoder and VAE streamed from the checkpoint file on an NVMe drive (Recipe A), BF16; measured at 864×480 (at the native 768P the cookbook says to use video_vae=24 if the decode runs out of memory, not measured); lab run with VRAM capped at 12 GiB and a simulated 32 GB host: shows the memory fits, not your card's speed; a real 32 GB machine re-reads the weights from disk on every step. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
| Apple Silicon Mac (64 GB unified) | – Unknown No published H3 recipe checked here for this device. |
| Mac with M5 Max, 40-core GPU (128 GB unified) | – Unknown No published video recipe matches this quick setup. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
| Mac Studio M3 Ultra (256 GB unified) | – Unknown No published video recipe matches this quick setup. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
| Mac Studio M3 Ultra (512 GB unified) | – Unknown No published video recipe matches this quick setup. H3-Base FL2VA, source recipe canvases only. Disk-streaming routes assume an NVMe drive. Host-RAM and lab assumptions remain in the full checker; full 2K needs an API. |
Machine-readable: the same answers as JSON (CC BY 4.0, attribution "RigCheck").
Related hardware
Graphics card and Mac pages where this page's checker gives an answer, smallest memory first: graphics cards with 64 GB of system RAM, Macs with their unified memory, in the finder's quick mode (published recipe match; each page lists every model).
- RTX 3060 12 GB: Hardware memory matches a published video recipe; exact clip peak unverified
- RTX 4060 Ti 16 GB: Hardware memory matches a published video recipe; exact clip peak unverified
- RTX 3090: Hardware memory matches a published video recipe; exact clip peak unverified
- RTX 4090: Hardware memory matches a published video recipe; exact clip peak unverified
- RTX 5090: Hardware memory matches a published video recipe; exact clip peak unverified
All graphics cards · All Macs · Any other machine
FAQ
How much VRAM does MiniMax H3 need?
Published recipes start at 12 GB of VRAM on an NVIDIA GPU, with the weights streamed from at least 32 GB of system RAM and an NVMe drive (SGLang, measured with the memory capped in a lab). Keeping all weights on the GPU takes far more: the BF16 files for one task are 144 GB, and SGLang's resident setups use 4× H100 80 GB (66.0 GB peak per card) or one 192 GB AMD MI300X (137.6 GB peak).
Can MiniMax H3 run on an RTX 4090 or RTX 5090?
With the weights streamed from system RAM, published runs say yes for an RTX 5090 and an RTX 4090 D (a different card from the standard RTX 4090; the cookbook lists its recipe as verified on an RTX 4090 24 GB, but its only timed single-card run is on the 4090 D). SGLang's cookbook measured the RTX 4090 D (host RAM not stated) making a 1344×768, 107-frame clip with 20 steps in 405.6 seconds at BF16 and 303.3 seconds with int8, with the GPU peaking at about 18 GB; and an RTX 5090 desktop with 60 GB of RAM, 8 GB swap and NVMe making an 864×480, 124-frame clip with 20 steps in 112 seconds. vLLM's recipe also lists single-card RTX 4090 and RTX 5090 configurations for FastH3, FastVideo's few-step derivative (different weights, prompt plus reference image, on a vLLM-Omni pull-request branch), which the recipe has not verified on a GPU (see What hardware can run MiniMax H3?).
Can MiniMax H3 run on a 12 GB or 16 GB GPU?
The SGLang cookbook has a 12 GB recipe (with 32 GB of RAM and an NVMe drive) and a faster 16 GB one (which pins about 117 GB of weights in RAM), and diffusers documents an int8 recipe for 12–16 GB cards with a small canvas and about 75 GB of RAM. The 12 and 16 GB runs were measured at 864×480 on a lab machine with the memory capped, so they show the memory fits at 480P, not a 12 or 16 GB card's speed; at the native 768P the cookbook says to keep fewer layers on the GPU (not measured). We found no recipe for 8 or 10 GB cards.
How much system RAM does MiniMax H3 need?
At least 32 GB in the smallest recipe, and then the weights are re-read from the drive on every step. More RAM is faster: SGLang's 16 GB recipe pins about 117 GB, diffusers' int8 recipes keep about 75 GB in RAM, and the RTX 5090 run used a 60 GB desktop plus an 8 GB swap file that finished full. The checker requires that swap condition; equivalent allocation without swap is unverified. Two-card RTX 5090 or RTX 4090 setups want a 384 GiB-class host (sold as 384 GB).
Can I run MiniMax H3 on a Mac?
We found no published run on a Mac. diffusers lists Apple's "mps" device for its offload recipe, and stable-diffusion.cpp, which runs Unsloth's GGUF files, is a cross-platform runtime, but nobody has published memory needs or times for H3 on Apple silicon (checked October 12, 2026).
Is there a MiniMax H3 GGUF?
Yes, from the community. Unsloth publishes GGUF files of the pruned transformers (6.7 GB at Q2_K to 21.4 GB at Q8_0) and of the text encoder (13.1 GB and 18.2 GB) for stable-diffusion.cpp, which can keep the text encoder on the CPU and offload to the CPU for smaller GPUs. Unsloth gives no VRAM figures. These are not llama.cpp or Ollama files: H3 makes video, not text.
Does MiniMax H3 run in ComfyUI?
Yes. ComfyUI supports it natively (0.30.0 or later for the text-, image- and reference-to-video templates) with files from Comfy-Org: the templates load a 21.0 GB pruned int8 transformer. In SGLang's lab comparison, ComfyUI ran the unpruned bf16 files with a 12.1–12.3 GiB peak under a 12 GiB memory cap; on a real 60 GB desktop its default command was killed while loading and needed --fast-disk, where an RTX 5090 took 141–146 s per 480P clip.
Can I use MiniMax H3 in the US, the EU or the UK?
Not under the open-weights license: its territory excludes the European Union, the United Kingdom, South Korea and the United States. MiniMax says organizations there can apply for a separate license, and that its API is available worldwide.
Can MiniMax H3 make 2K video locally?
Not yet. The open weights generate at a 768-pixel short edge (1344×768 at 16:9). MiniMax's 2K output comes from a regeneration step that is only available through its API for now; MiniMax says it will open-source it once it is ready.
Is MiniMax H3 open source?
The weights are downloadable from Hugging Face under the MiniMax H3 Community License, which limits where you may use them (see above) and adds conditions for commercial use. The text encoder is Qwen3-VL-32B under Apache 2.0.
Sources
- Hugging Face: MiniMaxAI/MiniMax-H3 (model card, file sizes, LICENSE, license Q&A; read October 12, 2026)
- SGLang cookbook: MiniMax-H3 (recipes, consumer GPU tuning, every measured time and peak memory; read October 12, 2026)
- diffusers documentation: MiniMax-H3 (memory recipes) and vLLM recipe (two-GPU profile, component sizes; FastH3 single-card profiles, read October 22, 2026, with the FastH3-Omni-NVFP4-QAD and FastH3-Omni-8-Step-V1 model cards for their licence)
- ComfyUI MiniMax H3 guide and Comfy-Org/MiniMax-H3 (templates, versions, file sizes)
- Hugging Face: unsloth/MiniMax-H3-GGUF (GGUF sizes, stable-diffusion.cpp command)
- The 8 GB OS reserve and the 144 GB host-RAM figure for diffusers' 80 GB recipe are RigCheck assumptions, stated under the checker.