Load Diffusion Model INT8 (W8A8)

This is the loader-side answer to "how do I run this in INT8." Instead of loading a checkpoint normally and converting it afterward, this node loads straight into 8-bit weights with 8-bit activations (that's the "W8A8" in the name) using torch._int_mm for the fast matmul path. Point it at a pre-quantized checkpoint, or point it at an ordinary float/fp8 one and let it quantize on the way in.

Where this fits

INT8 matters most if you're not on a 40-series-or-newer card - fp8 needs hardware acceleration that 30-series GPUs simply don't have, while ComfyUI's native INT8 path (ConvRot) runs on 20/30/40/50-series alike. That's the whole reason this pack exists: to get you onto INT8 without waiting for someone else to publish a quantized checkpoint, or to load one when someone already has. A handful of pre-quantized options exist already - Vistralis has published INT8 FLUX.2 Klein checkpoints (both the 4B and 9B, base and distilled), and there are community INT8 conversions of Chroma1-HD, Z-Image-Turbo, and Anima on HuggingFace. This node can load any of those directly, or take a regular checkpoint and quantize it itself.

How it works

Unlike Enable INT8 on MODEL, this node doesn't have an auto model type - you pick your architecture explicitly from a list of presets (sdxl, flux2, qwen, wan, chroma, z-image, and others). Each preset knows which layers of that specific architecture are safe to quantize and which to leave alone, so picking the wrong one means the exclusions won't match your model's actual structure. on_the_fly_quantization is the toggle that decides whether you're loading an already-INT8 file or handing it a float/fp8 checkpoint to quantize during load - when that's on, weight_dtype tells it what precision to expect the source weights in.

The same outlier_method choice from the adapter node applies here too: none for speed, convrot if you want the Hadamard-rotation approach that matches ComfyUI's own native format and generally holds up better on outlier activations.

The inputs and outputs that matter

• unet_name - the checkpoint file to load, from your diffusion models folder.
• model_type - pick the preset matching your actual architecture; there's no auto-detect here.
• on_the_fly_quantization - off if you're loading an already-INT8 checkpoint, on if you're quantizing a float/fp8 one during load.
• weight_dtype - the source precision (default, fp8_e4m3fn, fp16, bf16); matters mainly when on_the_fly_quantization is on.
• outlier_method - none or convrot in practice.

Output is a single MODEL, ready for a sampler, an optional Load LoRA INT8, or INT8 Lazy Torch Compile.

How to install it

• ComfyUI Manager - search "ComfyUI-INT8-Fast-Fork", install, restart.
• Manual - cd ComfyUI/custom_nodes && git clone https://github.com/SparknightLLC/ComfyUI-INT8-Fast-Fork, then restart.

Requirements are the same as the rest of the pack: a recent ComfyUI, an NVIDIA GPU with real INT8 throughput, and a matching PyTorch build. If you want a pre-quantized checkpoint rather than quantizing your own, the README links Vistralis's FLUX.2 Klein INT8 transformer weights and bertbobson's INT8 Chroma1-HD, Z-Image-Turbo, and Anima checkpoints - sizeable downloads, so budget disk space accordingly. If you're quantizing on the fly instead, you just need whatever float/fp8 checkpoint you already have.

Common issues & troubleshooting

Wrong output or degraded quality. Check model_type first. There's no auto fallback on this node the way there is on Enable INT8 on MODEL - if the preset doesn't match your architecture, the exclusion list is wrong for your model and quantization can hit layers it shouldn't.

Do you even need this node? ComfyUI's stock Load Diffusion Model can now load native .comfy_quant checkpoints directly as of mid-2026. If you already have a native-format INT8 file and don't need on-the-fly quantization or the Toolkit's runtime/outlier controls, the stock loader is simpler. This node earns its place when you're quantizing on the fly, using quarot/hadanorm, or want the runtime-backend tuning the Toolkit exposes.

Slow first load with on_the_fly_quantization on. That's expected - it's doing the quantization work at load time instead of you doing it once and saving the result. If you'll reuse the same model repeatedly, quantize once and save it with Save Model INT8 (DynamicVRAM Safe) so you're not re-paying that cost every session.

Placement in the graph. The README's recommended chain is Load Diffusion Model INT8 (W8A8) → optional Load LoRA INT8 → optional INT8 Lazy Torch Compile → sampler. Don't also run this model through Enable INT8 on MODEL - that node is for converting a stock-loaded model, and your model is already INT8 coming out of here.