MiniMax-H3-Image GGUF (ComfyUI)

GGUF quantizations of the MiniMax-H3-Image diffusion transformer for ComfyUI-GGUF. The bf16, int8 ConvRot and w4a8 versions, the text encoders and the VAE are in Comfy-Org/MiniMax-H3-Image; fp8 scaled and NVFP4 are in LSDJesus/MiniMax-H3-Image-fp8-nvfp4.

Modified files. These are quantized versions of MiniMax-H3-Image, made from Comfy-Org's minimax_h3_image_pruned_bf16.safetensors. MiniMax-H3-Image is licensed under the MiniMax-H3-Image Community License Agreement, Copyright © 2026 MiniMax. All Rights Reserved. See LICENSE and NOTICE. Among other terms, the license grants rights only outside the European Union, the United Kingdom, South Korea and the United States (sections I.5 and II), and it includes an acceptable use policy. Read it before downloading.

Files

File	Quantization	Size	Notes
`minimax_h3_image_pruned_Q6_K.gguf`	Q6_K	17.5 GB	Closest to the 8-bit versions
`minimax_h3_image_pruned_Q4_K_imat.gguf`	Q4_K, importance matrix	12.5 GB
`minimax_h3_image_pruned_Q3_K_imat.gguf`	Q3_K, importance matrix	10.0 GB	Smallest that holds up well
`minimax_h3_image_pruned_Q2_K_mix_imat.gguf`	Q2_K / Q3_K / Q4_K mix, importance matrix	9.25 GB	Experimental. Coherent, but visibly softer: fine texture smears and small text can break

All files run on any GPU ComfyUI-GGUF supports. GGUF weights are dequantized on the fly, so they are slower than the safetensors formats: about 1 step/s at 2048×2048 on an RTX PRO 6000, against 2.1 to 3.4 steps/s for fp8, int8, w4a8 and NVFP4 on the same card. If your card runs Comfy-Org's w4a8 (RTX 30 or newer) or int8 ConvRot (RTX 20 or newer), those are faster at a similar size: w4a8 is 12.5 GB, like Q4_K.

Requirements

ComfyUI with MiniMax-H3-Image support, merged on 10 November 2026 (ComfyUI 0.44). Older versions do not know the model.
ComfyUI-GGUF that accepts the minimax_h3 architecture. Without it the loader stops with Unexpected architecture type in GGUF file: 'minimax_h3'. Until the upstream change (city96/ComfyUI-GGUF#493) is merged, either run the patch script from this repo with the Python that runs your ComfyUI, then restart ComfyUI:
```
python patch_comfyui_gguf.py PATH/TO/ComfyUI
python_embeded\python.exe patch_comfyui_gguf.py ComfyUI      (Windows portable)
```
or make the same one-word edit yourself: add "minimax_h3" to IMG_ARCH_LIST near the top of custom_nodes/ComfyUI-GGUF/loader.py (the folder may be called comfyui-gguf):
```
IMG_ARCH_LIST = {"flux", "sd1", "sdxl", "sd3", "aura", "hidream", "cosmos", "ltxv", "hyvid", "wan", "lumina2", "qwen_image", "minimax_h3"}
```
The script finds the node under any folder name, changes only that line, keeps a loader.py.bak, and does nothing if the line is already there. If a later ComfyUI-GGUF update complains about local changes to loader.py, restore the original, update, and run it again.
The text encoder (qwen3vl_32b_minimax_h3_nvfp4_awq or _int8_convrot) and the VAE (minimax_h3_image_vae_fp16) from Comfy-Org/MiniMax-H3-Image.

Use

Put the .gguf in models/diffusion_models/ (or models/unet/). Open ComfyUI's MiniMax H3 Image template and replace its Load Diffusion Model node with Unet Loader (GGUF). Everything else stays as in the template: 6 steps, euler, simple, cfg 1. The model is made for 4 to 20 megapixels; the template starts at 4.

What is quantized

The same 200 layers that Comfy-Org quantizes in its int8 and w4a8 files: the fused qkv_proj, out_proj, mlp.fc1 and mlp.fc2 of the 50 transformer blocks, 95.8% of the weights. The token refiner, the condition projection, the adaLN time-curve basis, the patch and output projections and all norms are kept as in the bf16 source (BF16, F32 for 1-D tensors, F16 for the adaLN basis). The per-block int8 attention setting that Comfy-Org's files carry is kept, and so is the config metadata with the 6-step PDD schedule, which ComfyUI needs to load the model.

Importance matrix (_imat): per input column of each quantized layer, the mean squared activation over about 300,000 tokens per layer, collected from 12 calibration images (portrait, street, landscape, product, anime, oil painting, 3D, infographic text, macro, interior, fantasy, food) at around 4 megapixels and all 6 steps. The K-quant search then weights each column's error by it, as llama.cpp does. Neither test image below is in the calibration set.
Q2_K mix: blocks 0 to 3 and 46 to 49 at Q4_K, out_proj and fc2 at Q3_K, everything else at Q2_K. Plain Q2_K on all 200 layers breaks the image down to noise, even with the importance matrix.

The quantization is ggml's own code (ggml_quantize_chunk from an unmodified llama.cpp build), written to GGUF with gguf-py.

Quality

One render per file, seed 42, 2048×2048, 6 steps, compared with Comfy-Org's int8 ConvRot render (int8 ConvRot was the most faithful format in our tests of other models). Left: whole image; right: a 1:1 crop. A 6-step model changes its composition a little with any change to the weights, so differences in pose and layout are normal; look for broken texture and text.

The template's own prompt: