deAPI-ai/minimax-h3-33b-int8

MiniMax-H3 33B INT8 — joint video + stereo audio bundle

A single, self-contained checkpoint set for MiniMax-H3: a 33B DiT that emits video and 32 kHz stereo audio from one forward pass, so the result always carries a synchronized audio track. Text-to-video and image-to-video, 24 fps, 4–15 s clips, 768p default.

This bundle pairs the INT8 + ConvRot pruned DiT with the NVFP4/AWQ text encoder, both VAEs, the text-encoder configs/tokenizer, and short-schedule acceleration LoRAs — ~45 GB total instead of the ~385 GB of the full upstream release. Everything resolves locally from this directory; nothing is downloaded at runtime.

It also carries the Ref2VA reference pathway as an 87 MB add-on to the same trunk, so one resident model serves both first/last-frame generation and reference-conditioned generation without a second 21 GB checkpoint. See Reference mode below.

Credits

Original model	MiniMax — MiniMax-H3, 33B joint video + audio
Pruning, quantization and repack	Comfy-Org — the pruned INT8+ConvRot DiT and the NVFP4/AWQ text encoder in this repository are their consumer repack of MiniMax-H3, prepared for ComfyUI
Turbo LoRA and silu(t_emb) grid	larryvrh — 4–8 step distill, plus the ComfyUI-MiniMax-H3-Turbo node it ships with
PDD acceleration LoRAs	alibaba-pai — Parallel Decoding Distillation, 8-step, published for both the FL2VA and Ref2VA variants
ComfyUI conversions of those LoRAs	Kijai — the _pruned_comfy files, converted to match the pruned DiT's layout
Hybrid FL2VA/Ref2VA block range	smhfacct — published merged checkpoints whose b25-49 split this bundle reproduces at LoRA scale

deAPI-ai did not train or quantize any of these weights. This repository collects them into one directory laid out the way the original MiniMax-H3 release names its folders, and adds two files derived from the above by mechanical extraction and per-block selection — both described under Derived files.

Contents

Path	Component	Size	Format
diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors	H3 DiT, first/last-frame → video+audio	20.9 GB	pruned (rank-8 AdaLN), INT8 + ConvRot
diffusion_models/minimax_h3_ref2va_adaln_rank8.safetensors	Ref2VA adaLN pack — the modulation weights that turn the trunk above into a reference model	87 MB	rank-8 curve basis + 1025-point curve table
text_encoder/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors	Qwen3-VL-32B text/vision encoder	15.7 GB	NVFP4, AWQ
text_encoder/*.json, merges.txt, vocab.json	encoder config + tokenizer + preprocessors	11 MB	—
vae/minimax_h3_video_vae_fp16.safetensors	video VAE	5.2 GB	fp16
vae/minimax_h3_audio_vae_fp32.safetensors	audio VAE (32 kHz stereo)	605 MB	fp32
loras/minimax_h3_turbo_v4_step600_ema.safetensors	Turbo LoRA, 4–8 step distill	780 MB	bf16, rank 64 / 16
loras/h3_silu_temb_grid.safetensors	silu(t_emb) grid, restores the time conditioning the pruned DiT drops	5.5 MB	—
loras/minimax_h3_hybrid_b25-49_pdd_8step_pruned_comfy.safetensors	the same LoRA with blocks 25–49 taken from the Ref2VA distill	1.73 GB	rank 64, hybrid_ref2va_blocks=25-49

Directory naming. Folders follow the original MiniMaxAI/MiniMax-H3 layout, so the encoder lives in text_encoder (singular) — Comfy-Org's repack spells it text_encoders. Unlike that repack, the encoder's configs and tokenizer sit in the same directory as its weights, so the folder loads on its own.

Reference mode (Ref2VA)

MiniMax-H3 ships as two 21 GB checkpoints, FL2VA and Ref2VA. For serving they differ in one localized place: the per-block adaln_proj modulation weights and the curve table those are expressed in. minimax_h3_ref2va_adaln_rank8.safetensors is exactly that difference, lifted out of the Ref2VA checkpoint at 87 MB.

Load the FL2VA trunk plus the pack and one resident model serves both tasks — route a block to the pack's adaln_proj and its Ref2VA curve table when a request carries references, and leave every other block, and every first/last-frame request, bit-identical to the trunk. The pack covers all 50 blocks so the grafted range can be narrowed without re-extracting; 25–49 is the range the published hybrid checkpoints use.

The hybrid acceleration LoRA is the same idea one level down: blocks 25–49 carry the Ref2VA distill and everything else the FL2VA one, in a single file, so whichever pathway a request takes gets a LoRA trained on it. Pair it with the Turbo LoRA as the base and one resident model serves both tasks at 8 steps.

⛔ Ship them as a set. The rank-8 curve basis is not canonical: 4 of its 8 dims are sign-inverted between the FL2VA and Ref2VA checkpoints. A Ref2VA projection fed the FL2VA table silently negates half the modulation rather than failing, and a mismatched LoRA pair renders plausible, wrong video. Flat-weight similarity does not catch either — the cosine stays above 0.999 with four dims flipped. Use the adaLN pack and the hybrid LoRA from the same revision of this repository, and don't substitute a look-alike from elsewhere.

⚠️ Reference support is image-led. The pathway takes reference images, video and audio, but the acceptance testing behind the b25-49 range was done on image references. Video and audio references work and are gated by the model's own limits; treat their quality as less settled.

Derived files

Two files here are not copies of an upstream artifact. Both are produced mechanically, and both record what they came from in their safetensors metadata.

diffusion_models/minimax_h3_ref2va_adaln_rank8.safetensors — 101 tensors extracted from Comfy-Org's minimax_h3_ref2va_pruned_int8_convrot.safetensors: every block's adaln_proj plus the Ref2VA curve table. No weights are altered, combined or retrained; tensors are copied out and saved under their original names. Metadata carries the source filename and the SHA-256 of its safetensors header, so the extraction can be re-derived and checked.

loras/minimax_h3_hybrid_b25-49_pdd_8step_pruned_comfy.safetensors — built from Kijai's two _pruned_comfy conversions by per-block selection: for each target (adaLN, attention, feed-forward), block N is taken from Ref2VA-Acc-8Step when 25 ≤ N ≤ 49 and from FL2VA-Acc-8Step otherwise, with the token refiner and the final-layer PDD heads staying FL2VA. ⚠️ Those two source LoRAs are not shipped in this bundle — nothing here loads them at runtime; fetch them from alibaba-pai (or Kijai's conversions) if you want to re-derive this file. Nothing is averaged or re-projected. Selection is the only valid merge here, because each block's adaLN LoRA is already expressed in its own checkpoint's curve basis. The result matches the composition of smhfacct's published b25-49 hybrid, verified by probing tensors across the split boundaries.

Notes on the components

• Pruned DiT. The pruned variant replaces the full-width AdaLN branch with a rank-8 curve. That is what makes 33B fit in consumer VRAM, and it is also why h3_silu_temb_grid.safetensors is shipped next to the Turbo LoRA: the LoRA's AdaLN factors expect the 2688-dim silu(t_emb) that pruning removed. The PDD LoRAs above do not need it — their adaLN half is already projected into the rank-8 curve basis.
• INT8 + ConvRot stores the weights in a rotated basis. It is the quality-preferred variant of the repack and expects a PyTorch build with CUDA 13.0; the fp8_scaled upstream variant exists for setups that cannot use it.
• Sampling. The base checkpoint is a 50-step model. With the Turbo LoRA at strength 1.0 the useful range is 4–8 steps (6–8 looks best), per the LoRA author. The PDD LoRAs are 8-step and that schedule is not a preference: outside the distillation's window they do not render slower, they render wrong.
• Footprint. ~45 GB of weights; a machine needs ≥64 GB system RAM, and 768p generation peaks around 18–30 GiB VRAM depending on clip length. Reference-conditioned generation costs more than that on both axes, because the reference set is encoded into the same sequence the model samples over.

Licenses

This is a bundle of independently-licensed components. Each keeps its own license:

Component	Source	License
H3 DiT, VAEs, text encoder, tokenizer/configs	MiniMaxAI/MiniMax-H3	MiniMax H3 Community License Agreement
INT8+ConvRot / NVFP4 quantized repack of the above	Comfy-Org/MiniMax-H3	MiniMax H3 Community License Agreement
Ref2VA adaLN pack (extracted from the repack above)	derived here — see Derived files	MiniMax H3 Community License Agreement
Text encoder architecture / base weights	Qwen3-VL-32B (as shipped inside MiniMax-H3)	Apache-2.0 upstream; redistributed here under the H3 agreement
Turbo LoRA	larryvrh/MiniMax-H3-Turbo-Lora	Apache-2.0
silu(t_emb) grid	larryvrh/ComfyUI-MiniMax-H3-Turbo	Apache-2.0
PDD 8-step acceleration LoRAs	alibaba-pai/MiniMax-H3-Acc-LoRAs, converted by Kijai	MiniMax H3 Community License Agreement
Hybrid PDD LoRA (selected from the two above)	derived here — see Derived files	MiniMax H3 Community License Agreement

NOTICE

MiniMax H3 is licensed under the MiniMax H3 Community License Agreement, Copyright © 2026 MiniMax. All Rights Reserved.

Modified files. The DiT and text-encoder weights in this repository are not the original files: they are pruned and quantized derivatives (INT8+ConvRot and NVFP4/AWQ) produced by Comfy-Org, re-laid-out here into the original repository's directory structure. The VAEs are format conversions of the originals. Two further files — minimax_h3_ref2va_adaln_rank8.safetensors and minimax_h3_hybrid_b25-49_pdd_8step_pruned_comfy.safetensors — are derivatives produced by deAPI-ai from the components listed above, by tensor extraction and per-block selection respectively; neither introduces new training. Both are described under Derived files and inherit the license of what they were derived from.

Before you use these weights, read the MiniMax H3 Community License Agreement. It is not an open-source license: it limits the applicable territory, carries an acceptable-use policy, requires the "MiniMax H3" mark to be displayed on commercial products built with it, and requires separate written authorization from MiniMax for products generating over 20 million USD in yearly revenue.

The bundle is made available by deAPI-ai on Hugging Face, configured for integration with GamerHash AI's platform. All credit for the underlying models belongs to their respective creators listed above.

---

Hosted by deAPI-ai for use with GamerHash AI