MiniMax-H3-SVDQuant-fp4-pdd8

MiniMax-H3 SVDQuant FP4 + PDD 8-Step (Baked, Curve AdaLN)

A merged checkpoint for MiniMax-H3 (33B single-stream audio-video DiT, FL2VA) combining SVDQuant 4-bit quantization (rank 128) with the official PDD 8-step distillation (alibaba-pai/MiniMax-H3-Acc-LoRAs).

• The trunk LoRA (rank 64) is baked into the SVDQuant low-rank branches (global rank 128→320), so it adds zero runtime overhead; the PDD head bank switches the distilled output heads per sigma, enabling 8-step sampling.
• The AdaLN modulation tables use the curve parameterization (same as the Comfy-Org pruned release: one shared adaln_t_table + per-block [96768, 8] projections) instead of the raw bf16 tables. The PDD AdaLN LoRA is rebased into curve space (rebase_adaln_to_curve from the PDD package). This alone removes ~24GB from the checkpoint.

Result: 14GB checkpoint — 30% smaller than the official int8 (20GB), 3.4x faster than bf16.

Benchmarks (RTX PRO 6000 96GB, ComfyUI, 1344×768 × 141 frames @ 24fps, fixed seed)

3.4x faster than the bf16 baseline. Constrained-budget rows are measured on the 96GB card with ComfyUI's --reserve-vram capping the budget. With a 32GB (RTX 5090) budget this model runs in 129s at a 31.1GB peak, while the official int8 peaks at 32.9GB — beyond a 5090's physical 32GB, so it forces deeper offload there. The model keeps working down to a 12GB budget via block streaming, trading speed for memory.

Quality note: PDD 8-step distillation changes the sampling trajectory — the output is "another good video", not a frame-level approximation of the 20-step reference (LPIPS ~0.52 against bf16 is inherent to distillation, not quantization). Against the same-recipe int8+PDD baseline the LPIPS is ~0.37 with identical composition and no artifacts; the difference lives in fine texture detail.

RTX 5090 32GB measured (ComfyUI 0.34, sage, 1344×768 × 141 frames, seed 12345)

The 32GB card fits the 14GB checkpoint by default; the extra 1.7× comes from the patch nodes (memory-frugal sage attention + head-chunked attention + chunked FFN), not from residency. The same recipe on the int4 sibling at 24GB (4090) is even more dramatic (838 s → 189 s) because only the 14GB checkpoint can stay fully resident there — see 1ronman1993/MiniMax-H3-SVDQuant-int4-pdd8.

Timing note: our benchmarks used a remote text-encoder service (TE ~3 s). With a local qwen3vl-32B nvfp4 TE on a 24GB card, add roughly +130 s on the first run (weight load + dequant encode; measured 8.6 s + 122 s on a 4090D) and ~10-40 s when the TE has to swap back in for a new prompt; repeated runs with the same prompt skip TE entirely via conditioning cache. All compared stacks share the same TE cost, so the speed ratios are unaffected.

Recipe (KJNodes experimental MiniMax patches, SVDQuant-compatible build bundled in this repo as comfyui_kj_minimax_patches.py; if you also run full KJNodes, its upstream MiniMax nodes conflict by name — use one or the other): MiniMaxH3MemoryEfficientSageAttentionPatch → MiniMaxLowVRAMAttention (head_chunks 4) → MiniMaxChunkFeedForward (chunks 2) → ModelMemoryUsageFactorOverride (0.06; measured on ComfyUI 0.34 — if your build estimates differently, tune by the load_models_gpu log line: raise if you OOM, lower until the DiT reports fully resident). Wired-up workflow: minimax_h3_fp4_pdd8_workflow_24gb_api.json. Single-file plugin: comfyui_kj_minimax_patches.py → drop into ComfyUI/custom_nodes/.

Sample comparisons

Same prompt, same seed (12345), 1344×768 × 141 frames. The int8+PDD and this model share the exact same 8-step recipe, so their columns are directly comparable; the bf16 column is the 20-step undistilled reference (different trajectory — see the quality note above).

Prompt 1: "A golden retriever runs across a sunlit beach, splashing through the shallow waves."

Prompt 2: "A steam locomotive crosses a stone viaduct over a misty valley at dawn, whistle echoing."

Files

• svdq-fp4_r128-minimax-h3-curveadaln-pdd8.safetensors — main model → ComfyUI/models/diffusion_models/
• minimax_h3_fl2va_pdd_acc_8step_comfyui.safetensors — PDD head bank → ComfyUI/models/pdd_acc/ (ComfyUI conversion of the alibaba-pai release; the PDD node switches distilled output heads per sigma)
• comfyui-nunchaku-minimax-h3.tar.gz — the ComfyUI-nunchaku plugin build with MiniMax-H3 support (NunchakuMinimaxH3DiTLoader); unpack into ComfyUI/custom_nodes/ComfyUI-nunchaku/
• minimax_h3_fp4_pdd8_workflow_api.json — ComfyUI API-format workflow (plain)
• minimax_h3_fp4_pdd8_workflow_24gb_api.json — ComfyUI API-format workflow (24GB/32GB-optimized, see benchmarks)
• comfyui_kj_minimax_patches.py — SVDQuant-compatible KJNodes MiniMax patch nodes (standalone single-file plugin)

Requirements

• ComfyUI ≥ 0.33 (post MiniMax-H3 carried-audio rework)

• The bundled ComfyUI-nunchaku plugin (see above). It additionally requires the nunchaku Python package with MiniMax-H3 support — this is not in upstream yet, so build it from the fork (needs a CUDA toolkit with nvcc; ~10 min build):

  git clone https://github.com/cage1993/nunchaku.git -b feat/minimax-h3
  cd nunchaku && git submodule update --init --recursive
  NUNCHAKU_INSTALL_MODE=FAST pip install -e . --no-build-isolation
  

  Plugin python deps (pip install -r requirements.txt in the plugin folder) are only needed for the plugin's other model families; for MiniMax-H3 alone, diffusers, transformers, safetensors and accelerate suffice.

• ComfyUI-MiniMax-H3-PDD-Acc (provides MiniMaxH3PDDAccApply / MiniMaxH3SigmaShift)

• Remaining components from Comfy-Org/MiniMax-H3:

  • text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors → ComfyUI/models/text_encoders/
  • vae/minimax_h3_video_vae_fp16.safetensors and vae/minimax_h3_audio_vae_fp32.safetensors → ComfyUI/models/vae/

• sageattention (used by the patch nodes in the 24GB/32GB recipe)

Sampling recipe (must follow exactly)

• Sampler euler + sigmas from the MiniMaxH3PDDAccApply node output (8 steps), CFG = 1.0
• MiniMaxH3SigmaShift: shift_video = 12, shift_audio = 3
• MiniMaxH3PDDAccApply: lora_strength = 0 (trunk LoRA already baked into this checkpoint), head_strength = 1.0, nfe = 8
• Do NOT stack block-caching nodes (TeaCache / EasyCache / …) or other distillation LoRAs

License

• Derived weights of MiniMax-H3 — subject to the original model's license
• PDD Acc LoRA: alibaba-pai, Apache-2.0
• comfyui_kj_minimax_patches.py vendors nodes from kijai/ComfyUI-KJNodes, Apache-2.0