Run MiniMax H3 in Google Colab with ComfyUI

MiniMax H3 is a text-to-video model with a notable party trick: it generates audio with the video — dialogue, sound effects, music — in the same pass. This walkthrough runs it in ComfyUI on a Colab GPU runtime, from hardware check to a verified output file.

Two things set this apart from a smaller image-model run. First, the model is large: even the workflow-calibrated quantized set is around 39 GB, on a GPU class most subscribers will only see on higher tiers. Second, the license is not the permissive kind — check it before you build on this.

Before you start: license and hardware

License. MiniMax H3 ships under the MiniMax H3 Community License, and its terms matter here. The license's grant covers the world except the US, UK, EU, and South Korea, which are excluded territories — anyone there must contact MiniMax for a separate license before using the model. Colab VMs run in the US, so a Colab run is outside the licensed territory: the download is not technically gated, but running from the US without a separate license violates the terms rather than hitting a technical block. Weigh that yourself. The license is free for research, and for commercial use until your commercial products or services exceed $20M in annual revenue, with attribution required (a NOTICE file on distribution, and "MiniMax H3" displayed on commercial product UIs). One restriction applies everywhere: you may not use the model or its outputs to improve any other AI model — distilling H3 into a different model is prohibited, though H3's own derivatives are permitted.

Hardware. This run used a G4 runtime — an NVIDIA RTX PRO 6000 Blackwell with 96 GB VRAM, 176 GB RAM, and roughly 189 GB free disk. That is a Premium-tier GPU: expect it to be available only on higher plans, and to consume compute units fast. Do not attempt the downloads below on a smaller runtime's disk.

1. Verify the runtime before installing anything

G4 is a Blackwell datacenter GPU (sm_100). Older PyTorch builds have no kernels for it and fail later with "no kernel image is available" — check first, before any pip install can pull a mismatched torch as a side effect:

import torch
print("torch", torch.__version__, "| cuda", torch.version.cuda)
print("gpu:", torch.cuda.get_device_name(0))
print("arch:", torch.cuda.get_arch_list())
assert any(a in arch for a in ("sm_100", "sm_120")), "no Blackwell kernels — upgrade torch"

Our run: torch 2.11.0+cu128, CUDA 12.8, architectures including sm_100. If the assert fires, upgrade torch and restart the runtime before continuing:

!pip install -q -U torch torchvision --index-url https://download.pytorch.org/whl/cu128

Also check disk — the model set below needs ~39 GB free:

!df -h /

2. Install ComfyUI

%cd /content
!git clone https://github.com/Comfy-Org/ComfyUI.git

%cd /content/ComfyUI
!pip install -r requirements.txt

No custom nodes are needed: base H3 runs from single-file safetensors with ComfyUI's built-in loaders. (The GGUF node from the Qwen walkthrough is only needed for later community distills.)

3. Download the model set

Two stacks exist, and the official workflow template is calibrated to one of them:

Start with stack A — the template's defaults (the 8-step turbo LoRA, step counts) are tuned for it, and its int8/NVFP4 quants run efficiently (the NVFP4 encoder does not strictly require Blackwell, but it works well on one). Skip B entirely on a first run; the shared audio VAE (minimax_h3_audio_vae_fp32.safetensors, 0.6 GB) is required either way.

%cd /content/ComfyUI/models/diffusion_models
!wget -c "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors"

%cd /content/ComfyUI/models/text_encoders
!wget -c "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors"

%cd /content/ComfyUI/models/vae
!wget -c "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_int8_convrot.safetensors"
!wget -c "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors"

%cd /content/ComfyUI/models/loras
!wget -c "https://huggingface.co/lightx2v/Minimax-h3-Turbo/resolve/main/minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors"

Note the LoRA lives in lightx2v/Minimax-h3-Turbo, a different repo from the model. Verify everything before proceeding:

import os
for f in [
    "diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors",
    "text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
    "vae/minimax_h3_video_vae_int8_convrot.safetensors",
    "vae/minimax_h3_audio_vae_fp32.safetensors",
    "loras/minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors",
]:
    p = "/content/ComfyUI/models/" + f
    print("OK  " if os.path.exists(p) else "MISS", f,
          f"{os.path.getsize(p)/1e9:.2f} GB" if os.path.exists(p) else "")
!df -h / | tail -1

On our G4 run, the stack came to ~38.6 GB with roughly 150 GB still free. wget -c resumes if the runtime disconnects mid-download.

4. Get the workflow template

!wget -c "https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/templates/video_minimax_h3_t2v.json" \
  -O /content/video_minimax_h3_t2v.json

Unlike the Qwen-Image template trap, this subgraph-format template renders correctly in current ComfyUI. Import it by dragging the file onto the canvas — and always File → New first, because ComfyUI reopens whatever workflow was last autosaved.

If the "Missing Models" dialog appears on import, the template's dropdowns point at the stack you did not download. Click Download, or repoint the dropdowns (unet_name, clip_name, vae_name, audio_vae) at the files you staged.

5. Start the server and connect

Return to the ComfyUI directory — the downloads above left you in models/loras — then start. No --lowvram on the G4's 96 GB; the flag only slows it down:

%cd /content/ComfyUI

import subprocess, time
comfy = subprocess.Popen(
    ["python", "main.py", "--listen", "0.0.0.0", "--port", "8188",
     "--enable-cors-header", "*"],
    stdout=open("/content/comfyui.log", "w"), stderr=subprocess.STDOUT)
time.sleep(12)

The --enable-cors-header '*' flag is mandatory for tunnel/iframe access — without it ComfyUI 403s its own assets and the page renders blank. Reach the UI with Colab's proxy:

from google.colab.output import eval_js
print(eval_js("google.colab.kernel.proxyPort(8188)"))

6. Generate

The template's defaults on its subgraph node — all editable as widgets:

• Resolution: 864×480 (the ResolutionSelector defaults to 16:9 at 0.4 megapixels; the official 768p canvas is 1344×768 at 0.98 MP — set it after a first successful run)
• Duration: 5 s (snapped to a valid 124-frame length at 24 fps)
• Sampler: res_multistep, 4 base steps, CFG-distilled
• Turbo mode: OFF by default — switch it ON once the 8-step LoRA is loaded (strength 1.0) for fast drafts; leave it off for full quality
• Prompt: describe shots, camera moves, and the audio — dialogue, SFX, music — in one block, because the audio is generated from the same pass

Run it. A 5-second clip completes in a few minutes on the G4. Here is our first output, from a short scene prompt at the default 864×480:

The clip is 864×480, 5 seconds, with a stereo audio track (h264 video, stereo AAC at 32 kHz — confirmed with the ffprobe check below).

7. Verify the output

The whole point of H3 is the audio track — confirm it actually came through:

!ffprobe -v error -show_streams /content/ComfyUI/output/video/$(ls -t /content/ComfyUI/output/video/ | head -1) \
  2>/dev/null | grep -E "codec_name|channels|sample_rate"

Expect a stereo (channels=2) audio stream alongside the video stream. No audio stream means the audio VAE is disconnected or the wrong VAE is loaded — check the dropdowns, not your prompt. The embedded clip above passes this check: h264 video plus stereo AAC at 32 kHz. Outputs land in /content/ComfyUI/output/video/ and vanish with the runtime, so copy keepers to a mounted Drive folder.

Notes and limits

• Memory: the int8 stack peaks far below 96 GB VRAM. The bf16 stack works too — the 51.5 GB text encoder offloads to host RAM between passes — but encodes text noticeably slower.
• Known quality caveat: extremely fast motion smears fine facial detail.
• Speed distills (FastH3 step-distilled models, extra accuracy LoRAs) trade quality for speed; treat them as separate experiments.

Next

• Run Qwen-Image 2.1 in Colab with ComfyUI — the image-generation sibling of this walkthrough.
• Working in Colab — Drive persistence, compute-unit tracking, and access paths for web UIs.