MiniMax H3 Integrations

A community-maintained index of checkpoints, tools, and workflows for MiniMax H3, ordered by developer interest.

Official resources

Start here

This navigation guide is not a complete compatibility list.

Goal	Start with
Run on your GPU	Run locally — pick a stack from the VRAM table
Work with audio	`comfyui-minimax-h3-audio-T8` and audio VAE
Build in ComfyUI	Official tutorial · Workflows & nodes
Write better prompts	Prompting
Make it faster	Speed — Turbo · PDD · FastH3 · VDN
Control pose / depth / edges	Fun Control
Use the hosted model	Hosted H3 Max
Fine-tune it	Training & LoRAs
Serve it as an API	Serving H3
Run it on a dedicated host	Dedicated deployment — a private H3 / FastH3 host for one company
Run on Apple Silicon	`antirez/h3.c`

Run it locally

MiniMax-H3 generates video with native stereo audio from text, images, video, and audio inputs. It supports clips up to 2K and 15 seconds. Two base variants exist:

H3-Base-FL2VA (first-and-last-frame mode) — accepts zero, one, or two input images. Zero images for text-to-video; one image for first- or last-frame-to-video; two images for first-and-last-frame-to-video.
H3-Base-Ref2VA (omni-reference mode) — accepts up to 9 images, 3 video clips (2–15 s each), and 3 audio clips, for a maximum of 12 files total.

Checkpoints are the same size. FL2VA, trained only with keyframes, typically yields better raw output. Ref2VA accepts more reference material but has lower base quality; the Ref Patch can partially bridge this gap.

By VRAM and hardware

Find your GPU in the table, then use the notes to inform your configuration.

Situation	Stack	Why this combination
24 GB, first run	`pruned_int8_convrot` DiT (19.53 GiB) + TE `nvfp4_awq` (14.61 GiB) + `ComfyUI-MiniMaxH3-Easy`	Easy routes T2V, I2V, first/last-frame, and reference input through a single `Media` port. Sampling, LoRAs, and decoding remain outside the node for later modification.
24 GB, want speed	The above + TE-Speed-MiniMaxH3 + Turbo `v4_step600_ema` at 6–8 steps	Block-cache acceleration; v3.2 adapts to current ComfyUI's block prefetch and no longer patches core files. 6–8 steps reduce Turbo motion smear.
22 GB, Turing (sm_75)	`minimax-h3-turing` — W4A8 mixed + Turbo 4-step field handbook	5.7 min/clip baseline; T8 BlockCache drafts −43%; PDD 8-step + T8 combo 210 s/clip. sm_75 has no FP8/BF16 tensor cores — quantization, launch flags and kernel support all differ from Ampere+
12–16 GB	Pruned `Q4_K_M` GGUF (10.64 GiB) or pruned `nvfp4` (11.67 GiB) + TE `Q2_K` (7.91 GiB) + fp8mix VAE pair	GGUF offers the most size options, beneficial for tight memory. `IQ1_S` is smaller at 3.78 GiB, but quality noticeably drops.
8 GB	DiffSynth-Studio NF4 path	The project states 8 GB as its minimum for this path. Offloading performs most work here; expect slow performance, not just small memory footprint.
8 GB laptop (sm_120) + 16 GB RAM	`-h3-8gb-traps` — pruned INT8 ConvRot + nvfp4 text encoder, with a reproduction for each trap	The contributor reports 10 s / 768×1024 / 8 steps in 14.3 min, 20 steps in 33.8–43.5 min. `--disable-pinned-memory` is required — `MAX_PINNED_MEMORY = ram * 0.40` otherwise kills the process. The binding limit is the 16 GB of system RAM, not the 8 GB of VRAM: a ~34.5 GiB working set pages, and the symptom is a stalled sampler while `utilization.gpu` still reads 99% (`nvidia-smi` power is the tell — flat 34–36 W against 64–98 W healthy; 0.9–6 s/block fresh vs 212 s/block after ~1.7 h), so restart ComfyUI before each run. At H3's real geometry comfy-kitchen INT8 attention measures 22.8 ms against 143.1 ms for SDPA. Three-tier companion pack: `MiniMax-H3-8GB-Workflows`
RTX 50-series / Blackwell	NVIDIA Sol-Attn	1.14–1.44× faster than SageAttention with −37 % MLP peak VRAM, measured on a 5090. SM89–SM121, Triton 3.6.0. Also unlocks Blackwell-only hybrid-NVFP4 checkpoints.
H200 / B200, faster than real time	`OpenVDN/vdn-minimax-h3`, hybrid-attention H3 + 8-step adapter	Datacenter path, not a VRAM-saving one: the bf16 H3 base plus a linear-attention branch and two LoRAs. A 768p, 14.4 s clip denoises in 90.5 s on one H200, 51 s on one B200, and 11.23 s on 8×B200. See VDN.
Multi-shot / long video	`ComfyUI-H3-Motion-Context`	H3 generates in blocks up to 15 s. Motion-Context feeds the previous block's final frame and audio forward, preserving motion direction and speed. `Smite79/MiniMax-H3-LongVideos` is a second approach to the same problem, outside ComfyUI.
Pose / depth / edge control	`alibaba-pai/MiniMax-H3-Fun-Controlnet-Union` + `ComfyUI-H3-FunControl`	One ~6.8 GiB control branch covers Canny, Depth, HED, MLSD, Pose and video inpainting. See Fun Control.
Fewest steps	PDD 8-step Acc LoRA or FastH3	Alternatives to Turbo: PDD at 8 steps; FastH3 has a 4-step preview and 8-step V2 / Trim releases with different runtime requirements.
Storyboard / timeline	`ComfyUI_MiniMaxH3_Director`	Five importable templates: t2v, fl2v, r2v, v2v, and rv2v.
Inpaint / local edit	`scraed/LanPaint`	v2.1.0 fixed H3 support. Training-free video and audio inpainting.
Apple Silicon	`antirez/h3.c` (MIT, Metal-native)	h3.c supports T2V/A, first-last-frame, and ordered Ref2VA references end-to-end, with M3 Max / M5 Max performance optimization ongoing.
One-command local	`open-video-ai/open-video`	"Ollama for video models" — `install` · `pull` · `run`.

Checkpoints

Source	What it is	Files	Total
MiniMaxAI/MiniMax-H3	Original diffusers weights — `transformer/` (FL2VA) and `transformer_ref/` (Ref2VA) at 14 shards / 61.73 GiB each, plus text encoder, video VAE, audio VAE, and self-contained `FL2VA/` and `Ref2VA/` pipeline folders	280	464.2 GiB
Comfy-Org/MiniMax-H3	ComfyUI-repackaged single-file weights — 10 diffusion models, 3 text encoders, video + audio VAE	17	433.2 GiB

Variant	Name	Size
FL2VA	`minimax_h3_fl2va`	61.73 GiB
FL2VA	`minimax_h3_fl2va`	31.70 GiB
FL2VA	`minimax_h3_fl2va_pruned`	37.46 GiB
FL2VA	`minimax_h3_fl2va_pruned`	19.52 GiB
FL2VA	`minimax_h3_fl2va_pruned`	19.53 GiB
Ref2VA	`minimax_h3_ref2va`	61.73 GiB
Ref2VA	`minimax_h3_ref2va`	31.70 GiB
Ref2VA	`minimax_h3_ref2va_pruned`	37.46 GiB
Ref2VA	`minimax_h3_ref2va_pruned`	19.52 GiB
Ref2VA	`minimax_h3_ref2va_pruned`	19.53 GiB

"Pruned" means AdaLN-pruned. These models are roughly 40% smaller, work only in ComfyUI, and underpin most of the consumer-GPU quants below. For a 24 GB card, pruned_int8_convrot (19.53 GiB) is the usual starting point.

Quantized Models

MiniMax provides original BF16 checkpoints. The files below are community conversions and repackaged variants, not official MiniMax releases. Confirm compatibility with your runtime's documentation before downloading.

Community FL2VA conversions

Pruned	Method	Size	Download
	BF16	61.73 GiB
	Hybrid (fl2va base + ref2va adaln b15-49)	20.97 GiB
	Hybrid (fl2va base + ref2va adaln b20-49)	20.97 GiB
	Hybrid (fl2va base + ref2va adaln b25-49)	20.97 GiB
	Hybrid (fl2va base + ref2va adaln b30-49)	20.97 GiB
	ConvRot	31.70 GiB
	ConvRot Lean (HQ)	21.91 GiB
	ConvRot	20.94 GiB
	ConvRot Lite	20.33 GiB
	FP8 E4M3FN	43.78 GiB
	MXFP8	44.34 GiB
	FP8 + FP16 attention	26.70 GiB
	NVFP4 (HQ)	13.60 GiB
	NVFP4	10.86 GiB
	NVFP4	32.05 GiB
	NF4 (DiffSynth)	15.98 GiB
	OrbitQuant W4A4	17.03 GiB
	⚠️ DT-sQKV ConvRot	21.00 GiB
	⚠️ DT-sQKV ConvRot Lean	27.99 GiB
✓	BF16	37.46 GiB
✓	FP8 scaled	19.52 GiB
✓	ConvRot	19.53 GiB	┊
✓	NVFP4	18.69 GiB
✓	NVFP4 + ConvRot INT8	18.69 GiB
✓	NVFP4	11.67 GiB
✓	Mixed INT4/INT8 ConvRot	14.81 GiB	┊
✓	Mixed INT4/INT8 ConvRot Lean	17.27 GiB
✓	INT4 ConvRot	15.67 GiB
✓	Mixed INT4/INT8 ConvRot	18.92 GiB
✓	INT4 ConvRot	16.67 GiB
✓	INT4 ConvRot (pruned)	10.56 GiB
✓	W4A8 ConvRot	11.68 GiB	┊ ┊

GGUF quants — see the GGUF section.

Community Ref2VA conversions

Pruned	Method	Size	Download
	BF16	61.73 GiB
	ConvRot ┊ (patchin HF 1.02)	31.70 GiB	┊
	ConvRot Lean (HQ)	21.91 GiB
	ConvRot	20.94 GiB
	ConvRot Lite	20.33 GiB
	NVFP4 (HQ)	13.60 GiB
	NVFP4	10.86 GiB
	NVFP4	32.05 GiB
	NVFP4 mixed	22.76 GiB
	NF4 (DiffSynth)	15.98 GiB
	OrbitQuant W4A4	17.03 GiB
	Hybrid NVFP4, FFN-only (Blackwell)	16.38 GiB
	Hybrid NVFP4, QKV+FFN (Blackwell)	14.03 GiB
	⚠️ DT-sQKV ConvRot	21.00 GiB
	⚠️ DT-sQKV ConvRot Lean	27.99 GiB
✓	BF16	37.46 GiB
✓	FP8 scaled	19.52 GiB
✓	ConvRot	19.53 GiB	┊
✓	NVFP4	18.69 GiB
✓	NVFP4 + ConvRot INT8	18.69 GiB
✓	NVFP4	11.67 GiB
✓	Mixed INT4/INT8 ConvRot	14.06 GiB	┊
✓	Mixed INT4/INT8 ConvRot Lean	17.18 GiB
✓	INT4 ConvRot	15.67 GiB
✓	W4A8 ConvRot	11.68 GiB	┊ ┊

GGUF quants — see the GGUF section.

Community multi-tier repack

DeepBeepMeep/MiniMax-H3 collects community files at several precisions. Check the model card for compatibility and licensing.

Quants of the accelerated variants (VDN · PDD · FastH3)

These are quantized copies of the VDN, PDD and FastH3 models rather than of the base checkpoints. Match the quant to the runtime the parent model expects.

Parent	Precision	Method
VDN		ConvRot, ComfyUI layout
VDN		ConvRot, T8 repack
PDD 8-step		SVDQuant FP4
PDD 8-step		SVDQuant INT4
FastH3 4-step	GGUF	Community conversion

GGUF Quantized Models

GGUF files are community conversions, not part of the official MiniMax H3 release. Use a compatible loader and follow its documentation.

Community FL2VA GGUF conversions

Pruned	Size	Download
	17.42 GiB †
	14.50 GiB	┊ ┊
	14.50 GiB
	17.36 GiB	┊
	20.41 GiB
	18.50 GiB	┊ ┊
	18.49 GiB	┊
	21.21 GiB	┊
	24.17 GiB
	22.25 GiB	┊
	22.25 GiB	┊
	26.28 GiB	┊
	33.56 GiB	┊
✓	3.78 GiB — smallest DiT published
✓	4.22 GiB
✓	6.26 GiB	┊
✓	7.51 GiB
✓	8.16 GiB
✓	8.29 GiB
✓	8.90 GiB
✓	10.64 GiB	┊
✓	12.97 GiB
✓	15.45 GiB
✓	19.97 GiB
✓	20.10 GiB

† realrebelai ships Q2_K as a mixed-precision build, placing it above Q3_K_M. When comparing by size, prioritize the numerical value over the quant name.

Community Ref2VA GGUF conversions

Pruned	Size	Download
	14.50 GiB	┊ ┊
	14.50 GiB
	17.36 GiB	┊
	20.41 GiB
	18.49 GiB	┊ ┊
	18.49 GiB	┊
	21.21 GiB	┊
	24.17 GiB
	22.25 GiB	┊
	22.25 GiB	┊
	26.28 GiB	┊
	33.56 GiB	┊
✓	6.22 GiB
✓	8.12 GiB
✓	10.60 GiB
✓	10.60 GiB
✓	12.94 GiB
✓	14.00 GiB	‡
✓	15.42 GiB
✓	18.77 GiB	§
✓	19.94 GiB	┊

‡ molbal calls this one U16G — a hand-tuned mixed layout rather than a stock Q6_K. § molbal's Q8_CR is Q8_0 with ConvRot applied. Both are in the same repo as the plain quants; read the filename.

Fine-tuned checkpoint quants

DmitryDB also publishes stock-compatible quants of community fine-tunes of H3 — fine-tuned QKV weights in blocks 0–31 preserved alongside a tested quantization layout, no custom node or core patch required (the ConvRot / NVFP4 tiers match the base-model tiers exactly: 21.91 / 20.94 / 13.60 / 10.86 GiB, plus a ⚠️ DT-sQKV build at 21.00 GiB).

The fine-tunes themselves are third-party and are not itemised here; browse DmitryDB's model list directly for the current set.

Notes

DmitryDB/MiniMax-H3-INT8-Lean-ConvRot and DmitryDB/MiniMax-H3-ComfyUI-Quants are the same repo — the author merged and rebranded. Likewise …-INT8-Lean-ConvRot-Dynamic-Time-Separate-QKV and …-DynTime-sQKV. Both names in each pair resolve to the same files, so don't download twice.
t8star/minimax_h3_ref2va_patchin_hf102 is a weight modification, not a quant: +2 % on the 2×2 spatial high-frequency patch in the video-input projection. The author's own tests showed a weak HF-agent gain and did not confirm the "oily/waxy" look was removed. Treat as experimental.
Winnougan/MiniMax-H3-INT4_Convrot_ComfyUI ships a matching quantized text encoder: qwen3vl_32b_minimax_h3-w4a8_convrot.safetensors.
unsloth/MiniMax-H3-GGUF also carries Qwen3-VL text-encoder GGUFs: Q2_K_M 12.2 GiB and Q4_K_M 17.0 GiB.
DmitryDB/MiniMax-H3-ComfyUI-Quants also carries VAE files: video VAE FP16 4.85 GiB, audio VAE FP32 577 MiB.
VDN and PDD quants are not interchangeable with base quants. A VDN INT8 file expects the VDN adapters loaded; a SVDQuant PDD build already has the 8-step LoRA folded in, so stacking another acceleration LoRA on top will over-distill the result.
DiffSynth-Studio/MiniMax-H3-NF4 bundles NF4 TE + video VAE + audio VAE. Requires DiffSynth-Studio; the project states a minimum of 8 GB VRAM on this path.
WaveCut/MiniMax-H3-OrbitQuant-W4A4 bundles a quantized TE and FP32 VAE copies, and requires the ComfyUI-OrbitQuant node — the W4A4 path is not loadable without it. Workflow JSON.

Text encoders

MiniMax-H3 uses Qwen3-VL-32B for text and vision. On a 24 GB card, you will usually need to reduce the text encoder after reducing the DiT. The options are listed below.

Comfy-Org (official repackage)

Model	Precision	Size	Download
`qwen3vl_32b_minimax_h3`		47.97 GiB
`qwen3vl_32b_minimax_h3`		25.28 GiB
`qwen3vl_32b_minimax_h3`		14.61 GiB

The nvfp4_awq build at 14.61 GiB is the smallest official TE and the one to pair with a pruned INT8 DiT on a 24 GB card.

Community quantizations

Model	Size	Source
`qwen3vl_32b_minimax_h3`	13.58 GiB
`qwen3vl_32b_minimax_h3`	13.93 GiB
`qwen3vl_32b_minimax_h3`	25.28 GiB †
`qwen3vl_32b_minimax_h3`	15.35 GiB	— W4A8 ConvRot
`qwen3vl_32b_minimax_h3`	—	— W4A8 ConvRot
`qwen3vl_32b_minimax_h3`	12.2 GiB	— `Q2_K_M` GGUF
`qwen3vl_32b_minimax_h3`	17.0 GiB	— `Q4_K_M` GGUF
`qwen3vl_32b_minimax_h3`	7.91 GiB	— smallest TE published
`qwen3vl_32b_minimax_h3`	24.89 GiB	— quanto-INT8 ⚠️ no license

† Abiray's nvfp4_awq file is byte-for-byte the size of Comfy-Org's INT8 build, not of an NVFP4 one. Check the file before assuming it is a smaller download.

VAE and components

VAE (video & audio)

Both VAEs are required for every generation workflow — H3 decodes video and audio through separate autoencoders.

Component	Source	Size
Video VAE	Comfy-Org	4.85 GiB
Audio VAE	Comfy-Org	577 MiB
Video VAE	dummy9996	2.60 GiB
Audio VAE	dummy9996	289 MiB
Video VAE	Kijai	2.95 GiB

The fp8mix video VAE (2.60 GiB) plus the bf16 audio VAE (289 MiB) save roughly 2.5 GiB over the official pair — worth taking on a 12–16 GB card, where the VAE competes with the DiT for the same headroom.

Tiny Autoencoder (TAE) — previews only

A quickly-trained 2D tiny VAE by Kijai. The author's own assessment: not a great outcome, but it still beats latent2rgb for previews. 9 MiB. Currently only usable through the ModelPreviewOverride node in ComfyUI-KJNodes.

Component	Size	Download
TAE (preview VAE)	9 MiB

Image VAE (single-frame)

An experimental image-specialised H3 VAE that decodes a single temporal latent (T=1) into one still. Merged checkpoint — no custom node needed.

⚠️ For image workflows only. The image-tuned decoder materially regresses multi-frame video reconstruction, so keep the original VAE loaded for video.

Component	Size	Download
Single-image VAE (step 1597)	4.85 GiB

Ref Patch — FL2VA that behaves more like Ref2VA

Diffs the 112 keys shared between the ref2va and fl2va weights and stores the differences as a single 148 MiB patch, letting the lighter FL2VA checkpoint partially mimic Ref2VA behaviour. Apache-2.0. Requires the ComfyUI-MiniMaxH3_Ref-Patch node.

Component	Size	Download
Ref Patch	148 MiB

Fun Control — Canny / Depth / HED / MLSD / Pose + inpainting

alibaba-pai/MiniMax-H3-Fun-Controlnet-Union adds structural control to H3 without retraining the base model. It is a single ~6.8 GiB control branch — one control_proj_in plus five control_blocks grafted onto layers 0, 10, 20, 30 and 40 of the DiT's 50 — and one checkpoint covers every control type rather than one file per modality.


Control types	Canny · Depth · HED · MLSD · Pose, plus video inpainting and outpainting
Control input	`control_in_dim = 49` — the control video and the inpaint mask enter through the same projection
Strength	`control_context_scale` from 0 (ignore) to 1 (follow closely)
Guidance	Guidance-distilled: run at `guidance_scale = 1.0`. Raising CFG does not help and costs a second forward pass.
Frame count	Snaps to `17*n + 5`, up to 15 s at 24 fps
Upstream	`aigc-apps/VideoX-Fun` (★2244, Apache-2.0) — the training and inference code
ComfyUI	`wyzborrero/ComfyUI-H3-FunControl` (★34, Apache-2.0). Core ComfyUI support is open as draft PR #15860.

Runtimes

Engine	⭐	H3 support
`ComfyUI`	127159	Native, day-0. INT8 is now in mainline (commit `1a510f04`) — see Compatibility before reusing older INT8 quants.
`modelscope/DiffSynth-Studio`	12925	`MiniMaxH3Pipeline` in `diffsynth.pipelines.minimax_h3_audio_video`; docs at `docs/en/Model_Details/MiniMax-H3.md`, examples at `examples/minimax_h3/`. Ships NF4 quantized inference with an 8 GB VRAM floor.
`ModelTC/LightX2V`	2655	Full inference support: parallelism, quantized DiT, feature caching. Scripts at `scripts/minimax_h3`. Also the home of the Turbo 4-step / 768p LoRAs.
`NVlabs/Sana` Sol-Engine	8812	Hardware-specific full-stack runtimes (kernel optimization, Sol-Attn, approximate caching, memory-efficient decoding) on the `sol-engine` branch, Apache-2.0. Released full-opt configs for GB200, GB10, H100, A100, RTX 4090 and RTX 5090 with 3.55–4.52x speedup vs the matching baseline on the same hardware (e.g. 4.44x on a single RTX 4090, 768p@5s); launch via `scripts/launch_config.py`, local or Slurm. The branch now also ships Sol-H3, a standalone datacentre runtime — see Sol-H3.
`OpenVDN/vdn-minimax-h3`	397	Video Delta Net — a hybrid-attention rebuild of H3 that runs a frame-wise linear-attention branch alongside the softmax branch, shipped as plug-and-play LoRA adapters merged at inference. Apache-2.0, with training and inference code open, not just weights. See VDN.
`MiniMax-AI/MiniMax-H3`	5536	The official repository — reference implementation and prompt guides.
`antirez/h3.c`	1652	Apple Silicon native Metal engine, MIT, tutorial in the README. T2V/A, first-last-frame, and ordered Ref2VA references all working.
`MiniMaxH3ComfyUI/MiniMax-H3-ComfyUI`	101	Runs the 33B + Turbo LoRA locally with SGLang / vLLM / diffusers as selectable backends; T2V / I2V / R2V templates included.
`unslothai/unsloth`	70709	Lists MiniMax-H3 among the models it can run and train.
`komikndr/raylight`	473	Multi-GPU ComfyUI runtime with native MiniMax H3 support. Uses Unified Sequence Parallelism (USP) via xDiT to split image/video sequence computation across GPUs; Ray workers manage distributed execution. Apache-2.0.
`fluxmatrix/h3-flash`	5	H3 inference scripts and a resident web demo for 8×B200, with Ulysses sequence parallelism, compiled / parallel VAE decoding, and fused kernels. FLASH mode additionally uses LightX2V Turbo4 and changes the sampling trajectory. Published warm end-to-end benchmark protocol and results; Apache-2.0 code, model terms apply separately.
`slogonomo/sol-h3-studio`	1	Unofficial web studio, queue, HTTP API and CLI / MCP client for NVIDIA Sol-H3-Spark on one DGX Spark. Requires about 110 GiB free unified memory and 300 GB disk; patches the upstream pipeline. Portrait and non-5-second modes extend NVIDIA's validated recipe. Apache-2.0 code; H3 and LTX-2.5 weights have separate terms.
`TorchTPU + Diffusers`	—	Native PyTorch TPU inference with eager, `torch.compile` and tensor parallelism. Hugging Face publishes an H3 video/audio example on Cloud TPU v6e-4, TP=4, bf16, batch 1. TorchTPU code is Apache-2.0 with third-party notices; model terms apply separately.
`ddalcu/mlx-serve`	—	Native local app/server for Apple silicon; v26.10.3 adds FastH3 Omni reference-picture video with synchronized audio in 8 steps and image-aware prompt enhancement. The Mac app requires macOS 26.2+. MIT code; model terms apply separately.
`FlashML-org/FreeVideo`	—	Local ComfyUI workspace and launchers built on VDN-H3, with a documented 8 GB VRAM / 16 GB RAM path, community LoRAs, and Windows/Linux support. Apple silicon support is experimental. Apache-2.0 code; H3 Community model terms apply.
`drawthingsai/draw-things-community`	603	Engine behind the Draw Things app and `draw-things-cli` on Apple silicon: a native Swift / Metal implementation. Runs FL2VA (T2VA, first frame, first/last frame), Ref2VA with image and audio references, and FastH3 Omni from converted 8-, 6- and 4-bit weights. It can split work between the GPU and the Neural Engine, and imports H3 LoRAs in diffusers or ComfyUI layout. A first-party benchmark measures a 1024×512, 124-frame, 20-step clip at 201.87 s end-to-end on M5 Ultra, vs 246.79 s for the fastest other engine tested — see Reported environments. GPL-3.0 code; model terms apply separately.
`Openjutsu`	—	Local Next.js/ComfyUI app for H3 character and object swaps, combining SAM 3.1 tracking, visual prompt generation and editable workflows. Requires ComfyUI 0.41.2+, custom nodes and separate model downloads; the author reports an RTX 4060 Ti 16 GB / 64 GB RAM setup using INT8 streaming. MIT app; component and model terms apply separately.
`H3 Motion`	—	React/ComfyUI editor for keyframed subject motion with Time-to-Move and masked video-region regeneration with audio controls. Requires ComfyUI-vlo 0.3.0+, Comfy Kitchen INT8 attention and matching weights. Tested with ComfyUI v0.41.0-18 and WSL; the native Windows launcher remains untested. AGPL-3.0 code; model terms apply separately.
`MiniMax-H3 Studio`	—	Self-hosted web/API studio importing ComfyUI as a Python library, with a persistent FIFO queue and resident models, including FastH3 and Pika H3 Flex. Requires Linux, NVIDIA GPU and a separate ComfyUI installation; developed on RTX 4090 24 GB, with 64 GB+ system RAM recommended. Apache-2.0 code; ComfyUI and model terms apply separately.
`Tiiny Studio`	—	Desktop/Docker media app for Tiiny Pocket hardware. v0.4.0 adds H3-Turbo text-/image-to-video with sound and a persistent queue. Inference runs on the Tiiny device; the author tested Windows x64 and amd64 Docker, with other desktop builds smoke-tested. Apache-2.0 code; device and model terms apply separately.

ComfyUI workflows & nodes

Conditioning & orchestration

Node	⭐	What it does
`comfyui-minimax-h3-audio-T8`	653	v1.17.0, 62 nodes across eight menus: Audio (stable), Audio Experimental (multi-rate), Still, Conditioning, Models, Long Video, Speech, Source AV. Baseline ComfyUI `0.31.0`, commit `cbbc9dab1`, Python 3.10+.
`ComfyUI_MiniMaxH3_Director`	553	Provides five importable JSON templates: t2v, fl2v, r2v, v2v, and rv2v.
`ComfyUI-H3-Motion-Context`	491	Chains clips to maintain motion and sound continuity: clip A's last frames and audio inform clip B's start. Patches at runtime only; re-validates against current ComfyUI source on each start, refusing to run on mismatch — the safest patching approach in this list.
`ComfyUI_MiniMaxH3_Director`	359	The original Director.
`ComfyUI-MiniMaxH3-Easy`	332	Provides a compact workflow for T2V, I2V, first/last-frame, and reference video. Supports unified multi-media input with `@` references and inline dialogue blocks.
`ComfyUI-MiniMaxH3-Director`	182	Offers a timeline editor: drag media onto tracks, trim on a ruler, assign one prompt per shot, with live sampling preview, retakes, and shot chaining. The compiled final prompt remains visible during editing.
`ComfyUI-PainterNodes`	178	`MiniMaxRefToVideo2` node supports the official reference and dialogue format.
`ComfyUI-MiniMaxDirector`	49	Timeline editor: shots, camera moves and audio cues on a track, compiled into the single structured prompt from the official guides — camera as motion type × amplitude × speed, voiceovers, dialogue that crosses a cut, on-screen text — plus a WHO & WHAT card per named thing (face, voice, retention, face swap) and a linter for the rules the guides state. MIT.
`ComfyUI-H3-FunControl`	34	Loads `MiniMax-H3-Fun-Controlnet-Union` and exposes `control_context_scale` plus the Canny / Depth / HED / MLSD / Pose preprocessors and the inpaint mask path. Apache-2.0. Core ComfyUI support is still a draft PR, so this is the working route today.
`OpenH3-IR`	19	The ComfyUI side of OpenH3-IR (see Prompting), using its Context-IR service from the same repo, on a model you already run. Drop your pictures, clips and sounds on one panel, name them, then mention them by name in the sentence. The nodes and the service are one tool listed twice, not two projects.
`ComfyUI-FeiHou-Easy-H3`	66	Fork of MiniMaxH3-Easy with embedded 9-image / 3-video / 3-audio reference slots, saved media, prompt expansion and RefMod inputs. Experimental streamed-block mode must not be stacked with `ModelAttentionBackend / comfy kitchen attention`. GPL-3.0, with upstream attribution and retained third-party licenses.
`VPack`	—	Compresses encoded reference-video conditioning in H3 Ref2VA to reduce reference tokens. Independent of Spark-H3, with adjustable compression and a published baseline comparison; requires ComfyUI 0.38.0+ and reference video in `minimax_refs`. Apache-2.0.
`TARA-H3`	—	Experimental temporal alignment of native Ref2VA video-reference attention, with a technical report, implementation and examples. GPU compatibility and quality remain under evaluation; the dedicated step-1000 TARA LoRA was retired and is not a recommended checkpoint. MIT repository code; upstream component and model terms apply separately.
`ComfyUI-Dials`	—	Builds reusable training-free steering vectors from prompt pairs and applies them to H3 conditioning. Includes motion/style dials and workflows for native ComfyUI H3 and Pika Flex; use the matching model and workflow dependencies. AGPL-3.0 code; released dial weights use the H3 Community License.

Upscaling, loading & repair

Node	⭐	What it does
`scraed/LanPaint`	1331	Performs training-free video and audio inpainting; H3 support was fixed in v2.1.0.
`ComfyUI-MiniMaxH3_LatentUpscaler`	191	Latent spatial upscaler for H3's `NestedTensor` AV latents (video `[B,24,T,H/16,W/16]` + audio `[B,32,2,T_audio]`), which stock `LatentUpscaleBy` cannot process. Re-noises video and audio for two-pass sampling and scales `minimax_refs` / `minimax_keyframes` conditioning. `audio_denoise`: 0 locks audio, 1 fully remixes, 0.25–0.5 for light remixing.
`Comfyui_Minimax_h3_latent_Upscaler`	151	Learned neural upscaler for H3's 24-channel latents — generate at low resolution, upscale the latent in place, then refine at target resolution, skipping the `decode → pixel upscale → encode` round-trip through the ~5B VAE and the ghosting that naive latent interpolation introduces. Continuous 1.0–4.0× scale. Checkpoints on HF (bf16/fp16 ~691 MB, fp32 ~1.38 GB, Apache-2.0) with I2V and R2V example workflows; trained on ~80k paired samples.
`ComfyUI-H3VAE_TRT`	212	ONNX / TensorRT replacement for H3's ~5B video VAE — the decode stage, not the DiT. The author reports up to 1.7× on VAE decode. Apache-2.0, released 2026-09-01. Engines are built per GPU on first run.
`ComfyUI-INT8-Fast`	286	Largely superseded as INT8 is now native in ComfyUI. Its remaining value is `convert_comfy_quant.py`; see Compatibility.
`ComfyUI-H3-ResCascade`	—	H3 Hires Fix nodes and example workflows built on LBH's latent upscaler: refine a roughly 1 MP render to 1080p/1440p while retaining the first-pass audio. Tested by the author on RTX 5090 32 GB; long clips need substantial system RAM. MIT.
`ComfyUI Open-H3 Regenerate`	—	Community nodes and workflows for NVIDIA's three-step draft refiner, including its merged LoRA, fast VAE decoder and saved-latent recovery. Requires native H3 ComfyUI and the LBH upscaler node. Tested on Windows / RTX PRO 5000 72 GB; this is not a minimum VRAM claim. Apache-2.0 code; model terms apply separately.
`Tessera`	—	Spatially tiled, temporally chunked H3 video refinement with streamed VAE encode/decode, tile planning, optional detail anchors and saved-latent recovery. Uses H3 Ref2VA and the LMS detail LoRA; a general minimum-memory configuration is not established. MIT code; model and component terms apply separately.

Open-H3-Regenerate-2K

NVIDIA's code and weights refine an existing low-resolution H3 draft to 2560×1440 in three steps, using LBH latent upscaling, a refiner merged with LightX2V Turbo / LMS Sharp, and a distilled StreamRender-H3 VAE decoder. This is a refinement pass, not three-step generation from scratch; the default upstream audio stream is silence.

The standard dense reference and SoL-Engine paths have separate requirements. The optimized SoL path uses about 150 GB VRAM on B200/GB200; the community ComfyUI port above has its own tested configuration. Refiner, fast VAE and H3 base weights use the H3 Community License; LBH, LightX2V and LMS components retain their own terms.

Templates & example workflows

Official ComfyUI templates (these ship with ComfyUI; links allow viewing the graph without launching the app):

Text-to-Video (T2V) · Image-to-Video (I2V) · Reference-to-Video (R2V)

Community workflows:

MiniMax-H3 FL2V GGUF workflow — Loads and runs the GGUF-quantized FL2VA model.
joeygambino/MiniMax-H3-Multishot-Workflow — Strings several FL2VA/Ref2VA clips into one continuous sequence with matched audio handoffs. Apache-2.0 licensed.
javawock7618/comfy-MiniMax-H3-workflows — Bundles the entire low-VRAM acceleration stack into one importable workflow.
OrbitQuant T2VA · T2VA API form · Ref2VA API form — require ComfyUI-OrbitQuant.

Prompting

H3 prompts have a fixed three-part structure, inline <Picture X> / <Video X> / <Audio X> reference tags, and <d> for dialogue. Start with official guides, then use one prompt tool at a time. For reference audio, a clean, clearly spoken 10-second clip is picked up more reliably than a noisy one.

Read first: Base prompt guide · Reference-mode prompt guide

Tool	Why you'd pick it
`ComfyUI-MiniMax-H3-Promptor`	From v1.1.0, embeds `<Picture X>` directly into the narrative action line for "zero-hallucination inline annotation." Decouples visual analysis from text structuring, reducing API cost.
`ComfyUI-MiniMax-H3-Guide`	Zero dependencies. "Typed Plan v2" splits identity, keyframes, motion, edit source, voice, and score into explicit roles, compiles them into valid H3 prose, and routes to native nodes. Includes reusable image/audio reference sheets and a locked-frame Foley mode.
`OpenH3-IR`	Follows the Context-IR format and examples MiniMax published, rather than rewriting your prompt: it writes the document, then checks it and fixes what is wrong. Command line, HTTP, or its own ComfyUI nodes, on a model you already run. Apache-2.0.
`comfyui-minimax-h3-prompt-enhancer-T8`	Provides server-side prompt enhancement via `doubao-seed-evolving`.
`awesome-minimax-h3-prompts`	A prompt corpus with WebM examples and author attribution, categorized into story, action/fantasy, ad/product, music performance, and vlog.
`minimax-h3-prompt-skill-T8`	"Creative DNA" case library, installable as an agent skill, with an Electron desktop viewer.
MiniMax H3 1K prompt dataset	Curated 1K text-to-video prompts with author attribution: 3-field prompt-structure anatomy, 10 hand-picked reusable prompts, and an H3 vs. peer model comparison.

Agent skills

Skill packages that let a coding agent drive H3 without the ComfyUI canvas. They differ in how far they take you, and are listed here from the most complete: two carry a brief through to a finished file, one drives a local ComfyUI, and the rest write the prompt and hand it back for you to run.

Skill repo	Runs against	What it does
`awesome-minimax-h3`	Hosted API	Carries a brief through to a finished file against the hosted MiniMax API: submit, poll with backoff, resolve the returned `file_id`, then post-process with `ffmpeg`. Reports that the documented `/v2/…/query` polling form returns 404 and gives `GET /v1/query/video_generation` as the working call. Three `SKILL.md` packages — `minimax-video` for H3, plus Speech 2.8 and Music 3.0 skills that compose with it. Needs a `MINIMAX_API_KEY`, not local weights. MIT.
`okaypic-video-skill`	Hosted API (okaypic)	Carries a prompt through to a finished, captioned multi-shot episode: shot list, GPT/Gemini character and location reference sheets, two H3 takes per shot with generated dialogue and 5-frame contact sheets, a local timeline editor, and an `ffmpeg` final cut with burned-in English/Chinese captions and loudness levelling. Resumable batches that quote only what is left to render. Works from Claude Code and Codex (`SKILL.md`). Needs an `OKAYPIC_API_KEY`, not local weights. MIT.
`ComfyUI-Agent-Kit`	Local ComfyUI	Drives a local ComfyUI end to end from Claude Code, Codex, Gemini CLI, or Qwen Code — workflow building, hardware-aware model selection, multi-shot video. Ships a standalone H3 skill among its 581 templates. Apache-2.0.
`Minimax-H3-Prompt-AgentSkill`	Prompt only	Builds a formatted H3 prompt from your media and idea, then hands it back for you to run. No license stated.
`minimax-h3-opencode-skills`	Prompt only	OpenCode skill suite covering directing, routing, multi-shot planning, prompt generation, and review. MIT.

Also relevant: ComfyUI-PainterNodes (MiniMaxRefToVideo2, with the official reference and dialogue format), and minimax-h3-prompt-skill-T8 in the table above, which ships its case library as an installable skill.

Speed

Three levers stack: fewer steps, cheaper steps, and — newest — a cheaper model, where the architecture itself changes rather than the schedule. Check your PyTorch build first; an outdated CUDA build commonly causes slow generations.

Choose the checkpoint or adapter, sampler and schedule as one recipe. Do not stack distillation adapters unless the project explicitly supports the combination.

Family	Steps	Comes from	Pick it when
Turbo	4–8	LightX2V DMD distillation, plus community re-bakes	You want the most tested option with the widest checkpoint choice.
PDD	8	Alibaba PAI, on NVIDIA's Parallel Decoding Distillation	You want a single official-ish 8-step LoRA per variant and native ComfyUI loading.
FastH3	4 / 8	FastVideo, distilled H3 checkpoints and optimized runtimes	Preview, V2 and Trim for T2VA; Omni for image/video/audio-reference generation. Choose the checkpoint and runtime together.
Pika H3 Flex	6	Pika Labs, FL2VA / Ref2VA adapters	Native 480p/768p video with stereo audio and multimodal references, using the released six-step schedule.
VDN	8 or 50	OpenVDN, hybrid linear/softmax attention	You want an architectural speedup rather than a step-count trick, and have the disk for it.
PTD	4 / 6	EPFL VITA, Parametric Trajectory Distillation	Re-noised SDE adapters for four-/six-step sampling; full-model ComfyUI validation covers the paper's four-step checkpoint only.
DMAD	4 / 8	Distribution Matching as Adversarial Distillation	Four- and eight-step T2VA student LoRAs with Diffusers, ComfyUI workflows and public training code.

Attention-level work sits outside that table: VC-Attention makes each step's attention cheaper instead of removing steps, and is published but unreleased.

Field note from the 2080Ti and 4090 threads: PDD at 4 NFE visibly flattens painted-illustration texture where Turbo v4-600-ema still holds it. At the LoRA's intended 8 steps the gap mostly closes.

Turbo (Acceleration LoRA)

Turbo LoRAs are community acceleration models. Start with ModelTC/Minimax-H3-Turbo and lightx2v/Minimax-h3-Turbo, then use the workflow instructions provided by the project you choose. At 4 steps the audio track can degrade along with fast motion; 6–8 steps helps both.

Community Turbo checkpoint reference

Variant	Steps	Base	Precision	Size
`fl2v v0.1`	4	Full		1.29 GiB
`fl2v v1.0 768p`	4	Full		1.29 GiB
`fl2v v1.0 768p · comfyui`	4	Full		1.82 GiB
`fl2v v1.0`	8	Full		1.29 GiB
`fl2v v1.0 · comfyui`	8	Full		1.82 GiB
`lightx2v v0.1`	4	Full		1.82 GiB
`lightx2v v0.1 · rank-21 resize`	4	Full		300 MiB
`fl2v`	4	Full		744 MiB
`fl2v ema`	4	Full		744 MiB
`fl2v ckpt500`	4	Full		744 MiB
`fl2v ema ckpt500`	4	Full		744 MiB
`fl2v ckpt850` ← best 4-step under motion	4	Full		744 MiB
`fl2v ema ckpt850`	4	Full		744 MiB
`fl2v v4 step600`	4	Full		744 MiB
`fl2v v4 step600 ema` ← recommended default	4	Full		744 MiB
`fl2v pruned`	4	Pruned		592 MiB
`fl2v pruned ema`	4	Pruned		592 MiB
`fl2v pruned ckpt500`	4	Pruned		592 MiB
`fl2v pruned ema ckpt500`	4	Pruned		592 MiB
`fl2v pruned ckpt850`	4	Pruned		592 MiB
`fl2v pruned ema ckpt850`	4	Pruned		592 MiB
`fl2v pruned v4 step600`	4	Pruned		592 MiB
`fl2v pruned v4 step600 ema`	4	Pruned		592 MiB
`fl2v v1.0 768p · rank-21 resize`	4	Pruned		298 MiB
`fl2v v1.0 · rank-21 resize`	8	Pruned		327 MiB
`fl2v pruned ckpt500 V1`	4	Pruned		592 MiB
`fl2v pruned ckpt600 V4`	4	Pruned		592 MiB
`fl2v pruned ckpt600 ema V4`	4	Pruned		592 MiB
`fl2v pruned ckpt850 V1`	4	Pruned		592 MiB
`fl2v diffusers`	4	Full		0.79 GiB
`fl2v`	4	Full		717 MiB
`fl2v step 100`	8 NFE	Full		738 MiB
`fl2v step 200`	8 NFE	Full		738 MiB
`fl2v step 300`	8 NFE	Full		738 MiB
`fl2v 4-step` · ConvRot · ⚠️ dual-clock sampler or 8–10 steps	4	Full		779.9 MiB
`fl2v 4-step ema` · ConvRot	4	Full		779.9 MiB
`fl2v v4 step600 (T8-convert)` · ConvRot	4	Full		779.9 MiB
`lightx2v v0.1 · alpha8 T8-convert` · ConvRot · ⚠️ dual-clock sampler or 8–10 steps	4	Full		1.82 GiB
`fl2v v1.0 768p` · ConvRot · needs ComfyUI-LoraInt8Loader	4	Full		991 MiB
`fl2v v1.0` · ConvRot · needs ComfyUI-LoraInt8Loader	8	Full		991 MiB
`lightx2v v0.1` · ConvRot · needs ComfyUI-LoraInt8Loader	4	Full		991 MiB
`fl2v CMF`	4	Full	Q4TP (CMF)	25.20 GiB
`fl2v CMF · FL2VA`	4	Full	Q4TP (CMF)	25.70 GiB
`fl2v CMF · FL2VA (smaller)`	4	Full	Q2TP (CMF)	20.12 GiB

PDD (Parallel Decoding Distillation)

PDD comes from NVIDIA — arXiv 2607.26004, published 2026-07-28 — and was applied to H3 by Alibaba PAI as a pair of 8-step acceleration LoRAs.

alibaba-pai/MiniMax-H3-Acc-LoRAs ships one file per base variant:

File	For	Rank / alpha	Precision
`MiniMax-H3-FL2VA-Acc-8Step.safetensors`	H3-Base-FL2VA	64 / 64
`MiniMax-H3-Ref2VA-Acc-8Step.safetensors`	H3-Base-Ref2VA	64 / 64

Released under the MiniMax-H3 Community License, trained and served through aigc-apps/VideoX-Fun — the same project behind Fun Control.

Loading it. The LoRA is not a single flat adapter: it is a backbone LoRA plus 32 output heads, so a loader that expects one weight set will silently drop most of it. Current ComfyUI handles this natively through its LoRA-bank support. Otherwise use a repacked copy:

Conversion	Downloads	Note
`MiniMax-H3-Acc-LoRAs-ComfyUI`	31.6k	Straight ComfyUI key remap.
`Minimax-H3-Super-Acceleration-Comfy`	23.1k	T8's repack, aligned with the T8 audio node set.

ComfyUI node: Jalen-Brunson/ComfyUI-MiniMax-H3-PDD-Acc (★94, Apache-2.0) — use it if your ComfyUI predates LoRA-bank support.

FastH3 (preview, V2, Trim & Omni)

FastVideo combines video sparse attention (VSA) with step distillation. The original 4-step preview remains available; V2 and experimental Trim use eight steps and target text-to-audio-video, without distilled FL2VA or Ref2VA support. The separate Omni release adds eight-evaluation reference-conditioned video and audio generation.

Model	Downloads	Note
`FastH3-4-step-Preview-v1-VSA-DataFree`	109.5k	Full weights. Data-free distillation, so no dataset licence question follows it.
`FastH3-4-step-Preview-v1-LoRA`	20.9k	LoRA form, for stacking on a quant you already hold.
`FastH3_GGUFs`	—	GGUF conversions for the low-VRAM path.

FastVideo also publishes MLX INT8 and INT4 builds for Apple Silicon; check the FastVideo org page for the current set. NikoDemon80/ComfyUI-FastH3-Lora-Converter (★7) converts the LoRA into ComfyUI key order.

V2 and consumer-hardware releases

FastH3 8-Step V2 - Eight-forward, data-free DMD2 checkpoint with 80% VSA sparsity. Requires FastVideo's VSA-H3 backend and the checkpoint's trained schedule (video shift 10, not base H3's 12). T2VA only; FL2VA and Ref2VA were not distilled. Weights use the MiniMax H3 Community License.
FastH3 Trim NVFP4 - Experimental eight-step T2VA model retaining 42 of 50 transformer blocks, with rank-16 AdaLN compression. The NVFP4 transformer is 11.1 GiB and targets Blackwell GPUs / DGX Spark; pruning trades quality for size and speed. Check the model and component terms separately from FastVideo's Apache-2.0 code license.
Consumer-hardware recipes and measurements - October 6 release covering NVFP4 on RTX 5090 / RTX PRO 6000 / DGX Spark, FP8 on RTX 4090, and INT6 through MLX on Apple Silicon. The reported 8 GB Trim result uses an RTX 4090 capped to 8 GB, not a physical 8 GB card: 82.0 s for a 5 s, 832×480 clip with audio, warm end-to-end through MP4 export; the authors expect real lower-memory cards to be slower.

FastH3 Omni — reference-conditioned video and audio

FastH3-Omni 8-Step V1 - BF16 release checkpoint using eight transformer evaluations with ordered image, video and audio references. Requires at least one image or video; accepts up to 9 images, 3 videos and 3 audio clips, with at most 12 references total. Outputs 24 FPS video with synchronized 32-kHz stereo audio. MiniMax-H3 Community License.
Release variants and runtime recipes - BF16 server deployment through UniServe, NVFP4 QAD profiles for Blackwell / DGX Spark / RTX 5090, an FP8 route for RTX 4090, and ComfyUI variants. Keep each recipe's attention, precision and scheduler settings; non-FP4 hardware needs compatible text-encoder components.
Release and matched examples - Published October 20, 2026. The authors compare complete serving recipes on 8×GB200 across 27 matched workloads; timing and quality comparisons apply to those configurations, not every deployment.
Built by FastVideo in collaboration with Nuva Lab. Per the model card, Nuva Lab co-developed the model and defined and curated the omni reference dataset. For a managed host, see Dedicated deployment.

Pika H3 Flex

Pika H3 Flex releases six-step FL2VA and Ref2VA adapters for native 480p/768p video with synchronized stereo audio, with weights, a CLI, Diffusers examples and ComfyUI workflows. FL2VA covers text and first/last-frame conditioning; Ref2VA accepts image, video and audio references and requires at least one image or video. Use the released adapter, sampler and schedule together.

The official CLI's hardware guidance uses H100 80 GB as a validated environment, with CPU offload for larger requests; it runs one request on one GPU. Hosted 1080p/2K/4K refinement, audio stems and prompt enhancement are API extensions, not features of the released local weights. H3 Community License adapters and base weights; Apache-2.0 example code.

PTD (Parametric Trajectory Distillation)

vita-epfl/PTD-inference provides standalone four-/six-step inference and a native ComfyUI integration, with PTD weights, converters and example workflows. Requires the original unpruned H3 base and PTD-specific adapters, sampler and schedule; pruned, quantized, PDD and Turbo variants are unsupported.

The v0.2.0 release candidate adds re-noised h3_4step_sde / h3_6step_sde recipes for the current Hugging Face checkpoints, which replace the paper's adapters. The authors validate standalone sampling against their research implementation on H100. Full-model ComfyUI validation covers the paper's four-step T2V checkpoint with stereo audio, launched with --disable-dynamic-vram; the new SDE adapters, six-step and image-conditioned ComfyUI generation remain unvalidated on the full model. Apache-2.0 code; MiniMax-H3 Community License weights.

DMAD (four-/eight-step audio-video distillation)

Yzmblog/DMAD publishes four- and eight-step MiniMax-H3 text-to-audio-video LoRAs, Diffusers and native ComfyUI-layout weights, example workflows and training code. The October 29 8step_full_critic release is a student trained from scratch for eight-step sampling. Use the matching student weights and documented sampler/schedule; this entry covers T2VA, not an Omni-reference checkpoint. The H3 code is Apache-2.0 and the weights use the MiniMax-H3 Community License; the separate image-training subfolder has different terms.

VDN (Video Delta Net)

OpenVDN/vdn-minimax-h3 (★397) is the one entry here that changes the architecture instead of the schedule. Softmax attention is quadratic in sequence length and dominates step time at long clips, so VDN splits it in two: a sliding-window softmax branch for nearby frames, and a frame-wise linear-attention branch for long-range context. The change is added to the frozen H3 weights as a linear branch plus two LoRA adapters, merged at inference. Released 2026-09-06; write-up at openvdn.github.io. Weights .

Both the training and the inference code are open, which is unusual in this list — most acceleration work publishes weights only. The licence is split: Apache-2.0 for the code, MiniMax-H3 Community License for the weights.

Size. The repo is roughly 82 GiB in total. You do not need all of it:

Directory	Size	What it is
`h3-base/`	72 GiB	The rebuilt base. Only needed if you are training or evaluating from scratch.
`stage-b-step-2000/`	4.3 GiB	50-step adapter — the quality tier.
`stage-dmd-step-250/`	5.1 GiB	8-step DMD adapter — the speed tier.

Published figures. 2.6–2.9× faster per step than dense H3 on one H200/B200. A 768p, 14.4 s clip at 8 steps denoises in 90.5 s on one H200, 51 s on one B200, and 11.23 s on 8×B200 — faster than the clip plays, on that last configuration. Denoising only: VAE decode and muxing are excluded. All figures are the authors' own; see the environment report for the full stack they measured on.

ComfyUI node	⭐	Note
`Saganaki22/ComfyUI-VDN-H3`	202	The main node. Apache-2.0. Author reports 17 s/it at 1280×736 / 145 frames on an RTX 5090.
`Speach1sdef178/ComfyUI-VDN-H3-24GB`	4	24 GB-targeted fork with heavier offload.

Ready-made workflows for T2VA, I2VA, FL2VA, Ref2VA and reference audio ship with comfyui-minimax-h3-audio-T8, alongside a place-and-go model bundle .

The competing claim. Kablex/ComfyUI-Ref2VA-VSA (★111) applies video sparse attention to Ref2VA instead, and its author measures it at 2.24× faster than VDN-H3 — about 72 s per 5 s clip on an RTX 4090 in roughly 13.5 GiB. Both sets of numbers come from the projects themselves, on different hardware; neither has been reproduced independently here.

INT8 conversions of VDN for ComfyUI are listed under Quantized models.

Sol-H3 (datacentre)

The sol-engine branch of NVlabs/Sana now also ships Sol-H3, a standalone runtime rather than a per-GPU config. It is 4-step distilled, scales with Ulysses sequence parallelism to 8 GPUs, and uses SOL/BSA sparse attention.

Published medians on 8×B300 at 1344×768 / 24 fps with stereo audio, warm, excluding load, warmup and encode:

Frames	≈ Duration	T2VA	Ref2VA
124	5 s	1.653 s	2.192 s
243	10 s	3.732 s	4.348 s
362	15 s	6.612 s	5.947 s

ComfyUI wrapper: xmarre/ComfyUI-Sol-H3 (★21, GPL-3.0 — note the licence differs from the rest of this list).

VC-Attention (low-bit attention — paper only)

⚠️ No code released. VC-Attention is a published method, not something you can install. There is no repository, no kernel download and no license. It is indexed here because the measurements are on H3 and the technique is orthogonal to the four families above — not because you can run it today.

Rather than cutting steps, this line of work quantizes attention itself. V-Smooth reorders value tokens by lightweight online clustering to cut value-quantization error; ExpCast-FP8 folds the softmax exponential into a single fused multiply-add. QK runs INT8, PV moves to FP8 E4M3. No retraining is required, and the authors state it composes with existing sparse-attention methods.

Published figures, the authors' own, measuring the attention kernel against BF16 FlashAttention-4:

	B200	B300
VC-Attention	1.59×	1.51×
Nunchux Attention (proprietary)	1.91×	1.83×

End-to-end generation moves considerably less than the kernel does: the paper reports 1.13–1.19× on datacentre cards and 1.36–1.70× on workstation cards. Fidelity across 100 prompts is 20.2 dB mean PSNR against the BF16 reference, compared with 19.9 dB for SageAttention2.

⚠️ Two things share one name. VC-Attention is the paper. Nunchux Attention — the faster row above — is described by its authors as a proprietary extension available through Nunchux's hosted API, not as code.

Paper: arXiv 2609.15810, 14 Sep 2026 — Xingyang Li, Dongyun Zou, Shining Zhang, Jiacheng Chen, Haocheng Xi, Lvmin Zhang, Jun-Yan Zhu, Song Han, Zhekai Zhang, Yujun Lin, Muyang Li (MIT, CMU, UC Berkeley, Stanford, NVIDIA)
Write-up: Attention is the video bottleneck

Acceleration nodes

The figures below come from each project's own testing.

Node	⭐	Mechanism & published parameters
`ComfyUI-Spectrum-MiniMax-H3`	493	Spectral feature forecasting — fits post-transformer features with Chebyshev ridge regression and extrapolates future steps, skipping selected transformer evaluations. Adaptive scheduling with native fallbacks. The author is explicit that this is an approximation: output is not bit-identical to native.
`ComfyUI-SolAttn_triton`	266	SolAttention Triton kernel — optimized attention for H3 and other Sol-Attn models.
`ComfyUI-VDN-H3`	202	Runs the VDN hybrid-attention adapters. Apache-2.0. 17 s/it at 1280×736 / 145 frames on an RTX 5090, per the author.
`ComfyUI-Ref2VA-VSA`	111	Video sparse attention for Ref2VA. Author measures 2.24× faster than VDN-H3, ~72 s per 5 s clip on an RTX 4090 in ~13.5 GiB.
`ComfyUI-MiniMax-H3-PDD-Acc`	94	Loads the PDD 8-step Acc LoRA including its 32 output heads. Apache-2.0. Redundant on a ComfyUI new enough to have LoRA-bank support.
`ComfyUI-Sol-H3`	21	ComfyUI front end for the Sol-H3 runtime. ⚠️ GPL-3.0.
`TE-Speed-MiniMaxH3`	2	Block-cache accelerator, by the original TE-Speed author. v3.2 targets current ComfyUI (block prefetch, no core patch), adds a 4/8-step LoRA mode with automatic strategy selection by step count, a long-video (>10 s) cache strategy, and chunked CPU residual transfer; bundles a TE-Speed-compatible fork of the Sol-Attn node. ⚠️ Ships a compiled `nodes.pyd`, no license stated.
`Spark-H3`	—	Adaptive block-sparse attention with Diffusers integration and Linux/Windows ComfyUI packages for SM86 / SM89 / SM120. Apache-2.0. Compatibility: the October 25 notice reports regressions with newer `comfy-kitchen` on some setups and recommends validated ComfyUI 0.38.x while investigating; check that notice before upgrading, even though v0.1.5 added 0.42.x support.

Training & LoRAs

Training status. H3 includes weights and inference code, but no official trainer. The Hugging Face Diffusers integration is also inference-only. Everything below comes from the community.

Project	⭐	Notes
`verl-project/verl-omni`	1018	RL post-training for MiniMax-H3 LoRA adapters with FlowGRPO and DiffusionNFT. Recipes cover T2VA, FL2VA, and Ref2VA (Diffusers FSDP2 Actor + vLLM-Omni rollout, default CLAP + ImageBind rewards). Default GPU recipe is 8 GPUs; T2VA also has an Ascend NPU launcher.
`radixark/miles_diffusion`	42	Flow-GRPO RL post-training against reward models. The H3 t2va recipe is verified on 2×H200.
`IAmIronMan42/MiniMax-H3-FineTuning`	487	The most complete trainer currently available. Supervised rectified-flow training on top of the official Diffusers implementation, with latent caching (`prepare_cache.py`, `prepare_cache_pairs.py`) and a `FIXES.md` documenting nine fixes the author needed to make it converge. Verified scale: LoRA on 8×A800, 2000 clips of ~30 s at 448×768, ~65k tokens per sequence, stereo audio inside the loss.
`shootthesound/Fizgig`	157	LoRA / LoKr training studio with a built-in "✨ MiniMax H3 Fast" preset (LoKr, 8 dim / alpha 16, 60 epochs). Also does profile / repair / extract.
`inlineresearch/Inline-Studio`	213	Node-canvas film tool that trains H3 LoRAs on a local GPU. States "MiniMax H3 (4-bit, video) ~20.6 GB".
`ModelTC/LightX2V`	2655	The training side of Turbo distillation. The DMD config is public at `configs/minimax_h3/dmd`.
`unslothai/unsloth`	70709	Lists MiniMax-H3 among the models it can run and train. Check the current Unsloth documentation for the H3 workflow that fits your setup.

Ready-made LoRAs

Acceleration LoRAs and distilled checkpoints live in Speed. This section covers everything else.

Styles

LoRA	Size	What it does
minimax-h3-turnaround	60 MiB each	Contact-Sheet diffusion — one reference image + one instruction produces five coherent, progressively rotated views of the same subject in a single pass, by using H3's timeline as a slot axis rather than as time. A character turnaround from one photo: ~10 s at 512², ~57 s at 1024². Three builds: `1024-cont/s600`, `512/s1500`, `512-instruct/s400`.
Realism — People	125 MiB	Natural-looking people in everyday scenarios, trained by fal on diverse photo data. Works across T2V / I2V / R2V.
Looping Sketch Anime	569 MiB	Hand-drawn 2D outlines, flat colours, white outline, built to loop. Strength 0.75–1.25; pair with a Turbo LoRA if you want to push toward the high end.
Krea2 Style	1.03 GiB (r512) / 266 MiB (r128)	Experimental style shift toward Krea 2's aesthetics, extracted from a cross-model attn-graft (Krea2 attn K/V). Only effective for pure T2V. The author states r512 captures 52 % of the extraction target and r128 only 24 % (negligible) — prefer r512. MiniMax-H3 Community License.

Utility

LoRA	Size	What it does
RAVEN Streaming (4-NFE preview)	4.71 GiB	Turns H3 into a causal streaming generator — video is produced chunk by chunk, each extrapolated from prior content instead of denoised as one bidirectional clip (`r=128`, 4 NFE, 192 frames at 768×1376/24 fps, `sink=2` / `window=2`). Preview release by the RAVEN team (Imperial College); the authors state texture detail is still limited and real-time playback needs further inference acceleration. Runs through the RAVEN code repo, not ComfyUI. MiniMax-H3 Community License.
Prompt Rewriter	3.48 GiB	A Qwen3.6-27B fine-tune that rewrites a short prompt into H3's expected three-part structure. This is a language-model LoRA — it does not load into the DiT.
Prompt Rewriter 8B	2.60 GiB	The multimodal sibling of the Prompt Rewriter above: a Qwen3-VL-8B-Instruct LoRA that also sees your keyframes — covers T2VA, I2VA (first frame), L2VA (last frame), and FL2VA rewriting with an integrated shot timeline and synchronized physical/ambient sound and music guidance. Ref2VA is not supported. Also a language-model LoRA — it does not load into the DiT.

Serving H3

These projects are the main open-source options for serving H3 outside a ComfyUI workflow. SGLang and vLLM-Omni both ship official, hardware-verified H3 recipes; pick by ecosystem and by which published GPU profile matches your hardware. For a hosted API, see Hosted H3 Max; for a managed private host, see Dedicated deployment.

Project	Where it fits
SGLang	First-class H3 serving. SGLang Diffusion ships a native H3 pipeline with an official cookbook: `sglang serve --model-variant fl2va\|ref2va` covers t2va, fl2va, and ref2va (V2V is a ref2va use case), with every published recipe verified on real hardware — 4×H200/H100, B200/B300 (online quantization), 2×RTX 5090 layerwise offload, single RTX 4090 24 GB (`kitchen_int8`), and day-0 AMD MI355X/MI300X via ROCm + AITER. Also the selectable backend in `MiniMax-H3-ComfyUI`.
vLLM-Omni	First-class H3 serving on the vLLM stack. Since v0.26.0 it ships an official MiniMax-H3 recipe: OpenAI-compatible `/v1/videos` serving of T2VA, FL2VA, and Ref2VA from one diffusion stage that loads both DiTs and shares the TE and VAEs. Published profiles from 2× RTX 4090/5090 (CPU offload, ≥200 GiB host RAM) up to 4× B300/GB200, plus AMD ROCm.
EzgiTastan/minimax-h3-gb300-ebpf	Reproducible GB300 benchmarking and observability companion for SGLang H3 serving: end-to-end stage timing, Ulysses scaling, concurrency, host-side eBPF CUDA tracing, Grace–GPU PMU traffic, energy, and Nsight comparison. Includes retained measurements, figure renderers, and the full methodology and results.
vLLM	The underlying engine vLLM-Omni extends — vLLM alone serves autoregressive models, not H3's DiT. Deploy H3 through vLLM-Omni; keep plain vLLM for the text-model side of your stack (e.g. a prompt-rewriter endpoint).
UniServe	FastH3 T2VA and FastH3-Omni Ref2VA HTTP serving, with a Rust admission/scheduling server and Python GPU workers. Ships 1–8 GPU deployment recipes and latency/throughput evaluation on GB200, H200 and RTX PRO 6000. Requires Linux, NVIDIA Hopper/Blackwell and CUDA 13. Apache-2.0 code; model terms apply separately.

Hosted — the H3 Max family

⚠️ Closed weights. Everything else on this page is something you can download. The H3 Max models are not — they are hosted only, post-trained by fal, and reachable through an API. No quant, LoRA or acceleration node listed here will load against them.

Model	What it is
H3 Max	The hosted flagship. Post-trained on top of H3 by fal.
H3 Max Director	The interactive variant — a session you hold open while it generates, rather than a single request that returns a finished clip.
H3 Max Turbo	The speed tier of the hosted line. 1080p variants are also exposed.

Access is through fal and through the ComfyUI Partner Nodes, which call the hosted API from inside a normal ComfyUI graph. Announcements come from @Hailuo_AI and @ComfyUI.

Dedicated deployment

A private host that runs open H3 weights for one company. Use it when you need full concurrency, your own fine-tuned weights, or data that stays inside one deployment.

Provider	What it offers
Nuva Lab	Dedicated MiniMax H3 and FastH3 hosts. The standard host has 8× RTX PRO 6000; B200, B300 and GB200 hosts on request. Runs customer fine-tuned weights. Holds a MiniMax authorization for H3 deployments that serve US companies. Runs FastH3-Omni on dedicated hosts, with fine-tuning on customer data. FastH3 credits: co-developed FastH3-Omni with FastVideo and curated its omni reference dataset; credited for production grounding on the 4-step preview and 8-Step V2 model cards; UniServe serves production traffic at Nuva Lab and ran its benchmarks on Nuva Lab hardware. FastH3 overview: nuvalab.ai/fasth3. Cost and speed notes: self-hosting cost, VRAM and GPU requirements.

Provider

What it offers

Nuva Lab

Dedicated MiniMax H3 and FastH3 hosts. The standard host has 8× RTX PRO 6000; B200, B300 and GB200 hosts on request. Runs customer fine-tuned weights. Holds a MiniMax authorization for H3 deployments that serve US companies. Runs FastH3-Omni on dedicated hosts, with fine-tuning on customer data. FastH3 credits: co-developed FastH3-Omni with FastVideo and curated its omni reference dataset; credited for production grounding on the 4-step preview and 8-Step V2 model cards; UniServe serves production traffic at Nuva Lab and ran its benchmarks on Nuva Lab hardware. FastH3 overview: nuvalab.ai/fasth3. Cost and speed notes: self-hosting cost, VRAM and GPU requirements.

Compatibility & Licensing

ComfyUI INT8

ComfyUI includes native INT8 support. Older I8Fast files use different tensor names; use convert_comfy_quant.py or download a native-format quant.

ComfyUI patches

Some community tools modify or patch ComfyUI. Check the project's documentation and keep your ComfyUI version compatible.

Type	Project	Notes
Runtime patch	`DmitryDB/MiniMax-H3-DynTime-sQKV`	Required for its DT-sQKV files.
Runtime patch	`ComfyUI-H3-Motion-Context`	Checks its ComfyUI assumptions at startup.

Reported environments

comfyui-minimax-h3-audio-T8: ComfyUI 0.31.0, commit cbbc9dab1, Python 3.10+.
minimax-h3-turing: RTX 2080Ti 22G (Turing sm_75), ComfyUI 0.33.1 → master 345c919, PyTorch 2.9.1+cu130; W4A8 mixed + fl2v Turbo 4-step; T8 BlockCache −43% (drafts, non-reproducible), PDD 8-step + T8 210 s/clip
ComfyUI_MiniMaxH3_Director: RTX 4090 48 GB, ComfyUI 0.30.0, PyTorch 2.11.0, CUDA 12.8, Ref2VA INT8.
ComfyUI-VDN-H3: RTX 5090, 1280×736, 145 frames, 17 s/it.
ComfyUI-Ref2VA-VSA: RTX 4090, ~72 s per 5 s clip, ~13.5 GiB.
Sol-H3: 8×B300, 1344×768 @ 24 fps with stereo audio, warm medians excluding load / warmup / encode.
OpenVDN/vdn-minimax-h3 (VDN): H200 and B200, 1 GPU or 8 GPUs (Ulysses), Python 3.12, PyTorch 2.13.0+cu129, flash-attn-4 4.0.0b26, Triton 3.7.1, patched Diffusers, FP8 e4m3 linears; 768p × 14.4 s at 8 NFE: 90.5 s (1×H200), 51 s (1×B200), 11.23 s (8×B200), denoising only, VAE decode and MP4 muxing excluded.
matsuo-koya/minimax-h3-notes (★24, MIT) collects further single-machine run notes.
-h3-8gb-traps (MIT): RTX 5060 Laptop 8 GB (sm_120) + 15.26 GiB RAM, Windows 11 25H2, ComfyUI 0.35.0 (a7b1d39), PyTorch 2.14.0+cu130, Python 3.13.12; pruned INT8 ConvRot DiT + nvfp4_awq TE, launched with --disable-pinned-memory; 10 s / 768×1024 / 8 steps in 857.7 s; SDPA 143.1 ms vs comfy-kitchen INT8 22.8 ms vs SageAttention 29.0 ms at 56 heads × 128 / S=8192, bf16
Draw Things (first-party benchmark): Draw Things 26.1013.0 vs mlx-serve 26.10.2 and vpipe 0.1.80, each in its best configuration found; 1024×512 × 124 frames, 20 steps; sparse attention and step caching off for every engine. Draw Things uses 8-bit S weights (4-bit S on M6), with the Neural Engine + GPU on M3 Ultra, M4 Pro and M6, and GPU neural accelerators only on M5 Ultra. End-to-end: 201.87 s on M5 Ultra 80c / 256 GiB (fastest other: vpipe 246.79 s), 1239.95 s on M3 Ultra 60c / 96 GiB (vpipe 1377.44 s), 1589.02 s on M6 Mac mini 32 GiB (vpipe 1528.22 s — faster end-to-end, though Draw Things is faster per step, 66.32 s vs 67.73 s), 2761.3 s on M4 Pro 20c / 24 GiB (vpipe 3151.21 s). Draw Things model-loading time is included on low-RAM Macs.

Licenses

License	Where
Apache-2.0	`ModelTC/Minimax-H3-Turbo` and the Turbo LoRA line · Ref Patch · `aigc-apps/VideoX-Fun` · `Saganaki22/ComfyUI-VDN-H3` · `Jalen-Brunson/ComfyUI-MiniMax-H3-PDD-Acc` · `wyzborrero/ComfyUI-H3-FunControl` · `lihaoyun6/ComfyUI-H3VAE_TRT` · `NVlabs/Sana` sol-engine
MIT	`antirez/h3.c` · `matsuo-koya/minimax-h3-notes`
GPL-3.0	`xmarre/ComfyUI-Sol-H3` · `FX-FeiHou/ComfyUI-FeiHou-Easy-H3` · `drawthingsai/draw-things-community` — copyleft
MiniMax-H3 Community	`alibaba-pai/MiniMax-H3-Acc-LoRAs` · `alibaba-pai/MiniMax-H3-Fun-Controlnet-Union` · RAVEN Streaming · Krea2 Style
Apache-2.0 (code) · MiniMax-H3 Community (weights)	`OpenVDN/vdn-minimax-h3`
Closed / hosted only	The H3 Max family — no weights are distributed
No code released	VC-Attention — paper only; Nunchux Attention is proprietary and hosted
No license stated	`DeepBeepMeep/MiniMax-H3`

For other projects, check the repository or model card.

Acknowledgements

This index is only possible because other people made the models, tools, tests, and documentation it points to. Thank you to the MiniMax, ComfyUI, SGLang, vLLM, NVIDIA, and Unsloth teams, and to the independent maintainers who keep testing H3 on real hardware.

The structure and much of the resource discovery come from the community-maintained wildminder/awesome-minimax-H3. This page follows that work and adds MiniMax's own GitHub and Hugging Face scan.

More specific thanks go to:

Comfy-Org for the official ComfyUI conversions, workflow templates, and day-one support.
ModelTC / LightX2V for the Turbo distillation work and public training configuration.
Larryvrh for the checkpoint comparisons behind the Turbo guidance.
Kijai for the NVIDIA Sol-Attn implementation and benchmark notes.
Alibaba PAI and aigc-apps/VideoX-Fun for the PDD 8-step Acc LoRAs and the Fun ControlNet-Union branch.
OpenVDN for publishing Video Delta Net's training code alongside the weights.
FastVideo for the FastH3 line (4-step preview, V2, Trim and Omni), its data-free distillation recipe, and UniServe.
Nuva Lab for the production grounding behind FastH3, the FastH3-Omni co-development and reference dataset, and the production hardware behind the UniServe benchmarks.
Pika Labs for the six-step Flex adapters and inference examples; NVIDIA for the released draft refiner and fast decoder, building on LBH, LightX2V and LMS components.
IAmIronMan42 for the training work and the documented fixes.
Salvatore Sanfilippo (antirez) for the standalone H3 C/Metal inference engine.
Every quantizer and workflow maintainer represented above. Their files, testing time, and write-ups make local H3 use much easier.

If you spot a wrong number, broken link, or missing compatibility note, please open an issue or send a correction.

Contact

For MiniMax H3 questions, contact model@minimax.io.