Guozi MiniMax H3 Image Latent

MiniMax H3 is the 33B omni-modal video model MiniMax opened in August 2026 - native stereo audio, unified text/image/video context, the first serious open-weight answer to Veo's audio advantage. It is also, officially, a video model, and the native ComfyUI nodes floor you at five frames. This node is how you ask it for exactly one.

What it actually does

It writes a latent by hand. Two nested tensors, no model, no VAE call, no conditioning:

• video: [1, 24, 1, height // 16, width // 16] - one latent frame, 24 channels, 16× spatial compression
• audio: [1, 32, 2, 2] - 32 channels, stereo, 2 latent frames

Then it wraps both in a NestedTensor and hands you {"samples": ...} as a normal LATENT. That's the whole node.

The interesting part is why those numbers are what they are. H3's visual VAE is f16t4d24 - 16× spatial, 4× temporal, 24 channels - and the transformer's frame packing is (1, 4, 4, 4, 4): the first latent token is one frame, every later token is four. So a video latent with T=1 is a single frame, and the audio stream's canonical length for that is round(1 × 5/3) = 2 frames. The 2/3 rescale is why H3's audio runs at 40 latent Hz against 24 fps video. Those two zeros tensors are the smallest legal H3 audio+video latent, and the VAE special-cases a single-frame latent to decode exactly one image instead of running its temporal chunking.

So the "image VAE" in the node description isn't a separate checkpoint - there is no image VAE in the H3 release. It's the video VAE in its T=1 mode, and this node is the shape that makes that mode reachable.

Inputs and output

Two ints, and that's it.

width and height both default to 2048, min 32, max 8192, step 32. The step isn't decoration - H3's canvas snaps to multiples of 32, and the latent is pixels ÷ 16, so every 32 pixels of canvas is 2 latent pixels, which is what the 2×2 patchifier wants. 1024 is fine, 1000 is not.

The one output is LATENT. Wire it into the latents input of a KSampler and sample normally - H3's model wrapper handles the flat audio+video pack, so you don't need a special sampler. Then decode with the H3 video VAE. You get a batch of one image.

The default 2048×2048 is worth a thought. H3's documented generation canvas is a 768px short edge (1344×768 at 16:9); 2048 is the resolution H3 encodes reference images at, not the size it was trained to generate into. A 2048² latent is 64×64 patch tokens, roughly half the tokens of a 5-second 1344×768 clip, so it's cheap for what you get - but if the output looks soft or unstructured, drop toward canvas numbers before you blame the sampler.

Wiring the prompt side

You still need conditioning: either CLIPTextEncode through the H3 text encoder (Qwen3-VL-32B), or the positive output of the core MiniMaxH3ImageToVideo node with both keyframes left empty. Either way, set the same width/height there as here - H3's packed layout is keyed to the latent's actual geometry, and mismatched numbers are you asking the model to render a canvas it wasn't prompted for.

Install

The pack is shines77/ComfyUI-GZNodes by shines77 (Guozi), MIT, registered as comfyui-gznodes. It's new - created 21 September 2026, a handful of stars, no community footprint I could find - and this MiniMax node is the only genuinely new thing in it; the rest is a repackaging of KJNodes-style utilities (JoinStrings, VRAM_Debug, the constants), credited in the source.

cd ComfyUI/custom_nodes
git clone https://github.com/shines77/ComfyUI-GZNodes
# restart ComfyUI

Or install comfyui-gznodes from ComfyUI Manager, or comfy node install comfyui-gznodes.

Skip the README's pip install -r requirements.txt step. There is no requirements.txt in the repo - the pyproject's dependency list is empty and commented out - so that command just errors out. Nothing to install; restart is the install.

What you do need is a current ComfyUI. The node imports comfy.nested_tensor and relies on H3 support in core (the H3 checkpoints, the AV latent format, the single-frame VAE path). On an older build the import fails.

Model files, per Comfy's own H3 packaging:

ComfyUI/models/
├── diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors   (~21 GB)
├── text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors          (~16 GB)
├── 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     (optional, 8-step turbo)

fl2va is the text/first-last-frame checkpoint - the one for prompt-only runs. ref2va is the reference-to-video variant and wants reference inputs you don't have here. Unpruned bf16 is 66 GB per variant; pruned int8/fp8 is ~21 GB, and the text encoder alone is 51 GB bf16 versus ~16 GB at NVFP4-AWQ. On a 24 GB card, the quantized pair is the realistic target.

Things that will actually bite you

The licence, before anything else. H3's community licence excludes the US, EU, UK and South Korea from its "Applicable Territory" - you aren't licensed to run the local weights, or use their outputs, in those regions. That applies to whatever you make with this node.

Don't expect audio. The audio stream here is zeros standing in for a shape the DiT requires. It's sampled along with the video token and it is not the point; decode the video latent and ignore the rest of the pack.

Core has no equivalent, and that's the reason this exists. Empty MiniMax H3 AV Latent minimums out at 5 frames with a step of 17, because H3's video durations snap to a 17k+5 frame grid at 24 fps - 124 frames is ~5 seconds. You can't ask it for T=1. This node is the only way to get one frame in one pass.

A NameError about e at startup means something else failed first. The pack's top-level __init__.py guards its imports so one broken sub-package doesn't take the others down, but the MiniMax branch's warning message interpolates an undefined variable when the import fails. So the confusing traceback is a symptom: read upwards for the real error, which is almost always an old ComfyUI without H3 support.