MiniMax H3 Native FP16 Loader - Star7

MiniMax H3 is a 33B video model that ComfyUI loaded day-zero, and on paper it should be a disaster for anyone not holding a 40-series card. Full weights run around 42 GB. If you're on a Turing GPU - RTX 20 series, T4, Quadro RTX - you have no native BF16 Tensor Core support, which is what ComfyUI's default H3 path leans on, and forcing the model into FP16 naively tends to blow up numerically. MiniMax H3 Native FP16 Loader - Star7 is the fix for exactly that situation: it swaps the plain UNET loader for one that creates the model in FP16 from the start, installs the overflow guards, and leaves the INT8/ConvRot quantized path alone so you don't lose the speedup ComfyUI shipped in v0.27.0.

What it actually does

The loader does two things at model-creation time, instead of patching the model after the fact. First, it builds the H3 layers with FP16 compute and casts dense weights as needed. Second, it installs the "exact" numerical fix: the residual stream runs in FP32 across all 50 DiT blocks, the attention and MLP branch inputs get cast to FP16 where it's safe, SwiGLU pointwise math stays FP32, and the two overflow-prone projections - attention out_proj and MLP fc2 - are protected by power-of-two scales of 64 and 256. "Exact" describes that power-of-two transform, not bit-identical output across backends.

The bit that makes it worth choosing over a blunt FP16 conversion: it's quantization-aware. When you load an int8_tensorwise + ConvRot checkpoint, the loader keeps force_cast_weights=false, so the quantized kernels stay quantized instead of silently dequantizing into dense FP16. The official INT8/ConvRot H3 files (and the ~19.5 GB 10Eros_Max-style third-party ones, supported since v2.0.4) land at around half the full weight size, which is the difference between fitting on a 22 GB 2080 Ti and not.

Inputs, outputs, wiring

This is a loader, so it's about as simple as a node gets:

• unet_name - pick your H3 .safetensors from ComfyUI/models/diffusion_models. That's the only input.
• model (MODEL) - the output, which you wire into your sampler chain.

Recommended order from the README: loader → optional LoRA → optional attention patch → optional MiniMax H3 Activation Chunk - Star7 → Guider/Scheduler/Sampler. The chunk node isn't this pack's code - it's a separate companion pack - and the packaged RTX 20-series example workflow also wants the H3 audio-conditioning pack and VideoHelperSuite. ComfyUI Manager's "Install Missing Custom Nodes" handles all of that when you import the example.

Install

Install the pack (not the model) with ComfyUI Manager - search MiniMax H3 Native FP16 - Star7 - or the Comfy CLI:

comfy node install minimax-h3-fp16-exact-star7

Manual, if you prefer:

cd ComfyUI/custom_nodes
git clone https://github.com/star7code/minimax-h3-fp16-exact-star7.git

Restart ComfyUI. The pack itself has zero Python dependencies - it leans entirely on ComfyUI's native loader, MixedPrecisionOps, and quantization machinery - but you still need to download an H3 checkpoint into models/diffusion_models yourself. On load you'll see a diagnostic line like:

[Star7 H3 FP16] Enabled v2.0.7 | mode=loader-quantized | backend=int8_tensorwise+convrot:200 | force-cast=False | weight-patches=0 | blocks=50

That line is the whole story - check backend and force-cast to confirm your quantized layers survived.

When it does nothing (read this first)

On Ampere or newer (RTX 30/40/50), the loader logs "no FP16 repair needed" and hands off to ComfyUI's default loader with zero patches. That's by design - those cards have native BF16 and don't want this. Same for GTX 10-series (sm61), where FP16 throughput is too slow to bother. So if you were hoping this speeds up a 4090, it won't, and that's correct.

Two traps on the hardware it does target. Don't stack a second FP16 overflow fix on top of it - the loader already installs the repair, and the README is explicit that double-patching is only for deliberate testing. And if you apply standard ComfyUI LoRAs, be aware that dynamic/low-VRAM LoRA patches can dequantize the layers they touch; the console warns you when weight patches are attached. For Turing-class H3 generation that keeps the INT8/ConvRot speed, use this loader, wire the chunk node after it, and you get a surprisingly usable 20-series video rig.