How to run MiniMax H3 locally: ComfyUI and Diffusers setup guide

Hardware sizing tool. Before downloading hundreds of gigabytes, check your exact GPU compatibility, VRAM headroom, and host RAM requirements using our free MiniMax H3 VRAM Calculator.

MiniMax H3 is an open-weight omni-modal model generating synchronized video and native stereo audio from text or image prompts. Running a dense 33B-parameter transformer locally requires strict attention to memory allocation, checkpoint quantization, and CPU offloading tiers.

This guide provides the verified technical setup for running MiniMax H3 locally via ComfyUI and Hugging Face Diffusers, derived entirely from official documentation and confirmed benchmarks.

---

1. Architecture, open weights, and licensing caveats

MiniMax H3 combines two core deep learning components:

• Diffusion Transformer: A 33B-parameter dense single-stream transformer. It includes approximately 13B parameters in Adaptive LayerNorm (AdaLN) branches that can be precomputed for inference. Checkpoints labeled “pruned” drop these branches to minimize memory footprint.
• Conditioner / Text Encoder: A 32B-parameter Qwen3-VL vision-language model.
• Task checkpoints: Two official task variants are provided:
  • FL2VA: Text or first-and-last frame to video and audio.
  • Ref2VA: Reference image to video and audio.
• Canvas & resolution: The open-weight model runs at a native resolution of 1344×768 (768px short edge), 24fps, and generates approximately 15 seconds of footage with native stereo audio. 2K resolution is not included in the open weights and is only accessible through MiniMax’s hosted service.
• Repository size: The complete Hugging Face repository spans approximately 498 GB.

Licensing restrictions

The model is distributed under the custom MiniMax H3 Community License Agreement. While weights are publicly downloadable from Hugging Face and code is available on GitHub, the license imposes a strict commercial restriction:

Commercial use caveat: Commercial use of locally generated outputs requires an official MiniMax commercial license. ComfyUI documentation notes that Comfy is an official license reseller.

---

2. Hardware tiers and memory requirements

Official Diffusers documentation establishes clear memory tiers based on GPU VRAM and system memory availability:

The 24GB baseline: RTX 3090 & RTX 4090

For local workstations, a 24GB GPU is the primary practical threshold for running MiniMax H3. In ComfyUI workflows, the Qwen3-VL text encoder and diffusion transformer do not remain resident simultaneously.

An independent community benchmark by DmitryDB measured real-world memory draw on an NVIDIA RTX 4090 24 GiB (community, not official):

• int8-convrot-safe: 20.42 GiB peak VRAM (PASS)
• int8-convrot-balanced: 21.03 GiB peak VRAM (PASS)

Both benchmarks confirm that 24GB consumer cards comfortably accommodate the quantized diffusion model with sufficient margin for activation and VAE buffers.

The critical host RAM requirement

When running on GPUs under 48GB, transformer blocks must stream from system memory during inference. The official Diffusers guidance specifies ~75 GB host RAM at int8 precision. Systems with 16 GB or 32 GB of system RAM will encounter host-level out-of-memory crashes regardless of GPU configuration.

Note on unverified platforms: AMD ROCm performance, Apple Silicon / MPS execution, and specific per-GPU inference runtimes are not verified in official documentation and are omitted.

---

3. ComfyUI implementation route (comfyui minimax h3)

ComfyUI provides native node workflows for MiniMax H3 text-to-video (T2V), image-to-video (I2V), and reference-to-video (R2V).

Required ComfyUI versions

Ensure your ComfyUI installation meets or exceeds these release tags:

• >=0.30.0: Baseline support for T2V, I2V, and R2V templates.
• 0.34.0: Multiframe workflow support.
• 0.35.0: Fun ControlNet and sparse attention integration.
• 0.36.0: FastH3 implementation.

Required model files

Official ComfyUI weights are published under the Comfy-Org/MiniMax-H3 repository. Download the matching components for your VRAM target:

1. Diffusion Model (models/diffusion_models/):
   • pruned_int8_convrot (19.53 GiB) — Official template default, recommended for 24GB GPUs.
   • pruned_fp8_scaled (19.52 GiB) — Alternative 8-bit quantization.
   • pruned_w6a8 (14.89 GiB) — Compact 6-bit weight / 8-bit activation build for tighter budgets.
   • int8_convrot (31.70 GiB) — Unpruned 8-bit checkpoint.
   • pruned_bf16 (37.46 GiB) — Unquantized pruned model for >=48GB setups.
   • bf16 (61.73 GiB) — Unpruned full-precision baseline.
2. Text Encoder (models/text_encoders/):
   • qwen3vl_32b_bf16 (47.97 GiB)
   • qwen3vl_32b_int8_convrot (25.28 GiB) — Recommended for consumer systems.
   • qwen3vl_32b_nvfp4_awq (14.61 GiB) — Ultra-compressed NVFP4 variant.
3. Variational Autoencoders (models/vae/):
   • Video VAE: fp16 (4.85 GiB) or int8_convrot (2.62 GiB).
   • Audio VAE: fp32 (0.56 GiB) for native stereo generation.
4. Acceleration LoRA (models/loras/):
   • turbo LoRA (1.82 GiB).

Generation settings: steps and samplers

Configure the KSampler nodes in ComfyUI as follows:

• Sampler: res_multistep
• Scheduler: simple
• Step count:
  • Standard baseline: 20 steps.
  • With Turbo LoRA: 8 steps for T2V and I2V; 4 steps for reference-based generation.

Attention backends and the int8 caveat

• Sage Attention: Optional attention backend providing approximately ~2x speedup during diffusion passes.
• Attention caveat: Comfy Kitchen attention is NOT supported with int8-convrot checkpoints (ComfyUI issue #15529). If using int8-convrot or pruned_int8_convrot, you must leave attention set to default or Sage Attention.

---

4. Hugging Face Diffusers implementation route

MiniMax H3 is supported natively in Hugging Face Diffusers pipelines.

Downloading model weights

The full repository is ~498 GB. Download a single task using the official command from MiniMax GitHub:

# Download single task (FL2VA) from MiniMax GitHub
hf download MiniMaxAI/MiniMax-H3 --include "model_index.json" "FL2VA/*" --local-dir MiniMax-H3

Diffusers users can just use ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3").

Memory offloading configuration

In your Python pipeline script, initialize memory offloading based on your hardware tier:

import torch
from diffusers import MiniMaxH3Pipeline

# Initialize pipeline with ComponentsManager
pipe = MiniMaxH3Pipeline.from_pretrained(
    "./minimax-h3",
    torch_dtype=torch.bfloat16,
)

# For 1x 80 GB GPUs:
# pipe.enable_model_cpu_offload()

# For 12-32 GB GPUs: int8 precision + sequential block streaming
# Requires ~75 GB host RAM
pipe.enable_sequential_cpu_offload()

For 12–16 GB GPUs, set generation resolution to 960x544 and enable leaf-level offload for the video VAE. Official benchmarks indicate that 960×544 generates approximately 3x faster per step than the native 1344×768 canvas on constrained cards.

---

5. Troubleshooting and known failure modes

1. ComfyUI crash: Attention error with int8 checkpoints

• Symptom: Kernel errors or undefined symbol exceptions during the diffusion sampling pass.
• Cause: Comfy Kitchen attention is incompatible with int8-convrot quantization (ComfyUI issue #15529).
• Fix: Switch your attention backend to standard SDPA or enable Sage Attention (~2x optional speedup).

2. Host system freezes or process killed (OOM)

• Symptom: Python or ComfyUI terminates abruptly during model load or between the text encoder and diffusion stage.
• Cause: Insufficient system RAM. Offloading int8 weights requires ~75 GB host RAM.
• Fix: Increase physical host RAM to at least 75 GB or expand OS swap space on high-speed NVMe storage.

3. CUDA out-of-memory on 12–16 GB GPUs

• Symptom: torch.cuda.OutOfMemoryError during spatial VAE decoding or early diffusion steps.
• Cause: Attempting to decode the native 1344×768 canvas without leaf-level VAE offload.
• Fix: Reduce the generation canvas to 960×544 and enable leaf-level offloading on the video VAE.

4. Inability to generate 2K video

• Symptom: Settings above 1344×768 fail or distort.
• Cause: The open-weight model architecture is strictly bounded to a 1344×768 canvas (768px short edge).
• Notice: 2K resolution is exclusive to MiniMax’s commercial hosted platform and is not available in local open weights.

---

6. Official documentation and sources

All specifications and figures in this guide reflect verified primary sources fetched 2026-10-12:

• MiniMax-H3 on Hugging Face — Official model repository and Community License Agreement.
• MiniMax-H3 GitHub Repository — Official code and inference scripts.
• Hugging Face Diffusers MiniMax H3 Documentation — Official offload tiers and memory recommendations.
• Comfy-Org MiniMax-H3 Releases — Official ComfyUI quantized files and file sizes.
• ComfyUI MiniMax Tutorial — Workflow templates, step recommendations, and attention caveats.
• DmitryDB MiniMax-H3 ComfyUI Quants — RTX 4090 24GB peak VRAM measurements (community, not official).

To test your specific hardware setup against these requirements, use the MiniMax H3 VRAM Calculator.