Enable Quantization on MODEL

Most quantization nodes make you go find a special pre-quantized checkpoint. This one doesn't - it takes whatever MODEL you already have loaded, however you loaded it, and converts the eligible linear layers to 8-bit integers right there in the graph. If you've got a checkpoint sitting on disk and want it to run in INT8, this is the node that does it without a re-download.

Why INT8, specifically

You've probably heard fp8 is the easy win for VRAM and speed on Flux-class models. It is - if your card is a 40-series or newer. If you're on a 3090, 3060, or anything from the 30-series, fp8 gets you nothing, because those cards have no hardware fp8 acceleration at all. INT8 is the format that actually helps you. ComfyUI shipped native INT8 loading (with a specific rotation-based variant called ConvRot) in June 2026 for exactly this reason, and people running it on 30-series cards are reporting real gains - 40-50% faster on a 3090 isn't an unusual number to see. This Toolkit is what lets you get there from a model you already have, instead of waiting for someone to upload a pre-quantized version.

How it works

Drop this node after your regular model loader. model_type defaults to auto, which looks at the loaded model and picks a known exclusion preset - a list of layers that shouldn't be touched (output heads and other sensitive spots vary by architecture, and blindly quantizing them tanks quality). outlier_method controls how it handles the activation outliers that make naive INT8 quantization lossy: none does straight per-row quantization (fastest, and it's the default), convrot applies a grouped Hadamard rotation that's specifically built to match ComfyUI's own native ConvRot format, and quarot/hadanorm are older or experimental Toolkit-only approaches. Unless you have a reason not to, convrot is the one worth reaching for - it's the option that keeps your model compatible with ComfyUI's stock loader later if you save it out.

The setting that actually matters for anyone using LoRAs is bake_loaded_loras. Leave it on. If you've run stock Load LoRA nodes before this one, bake_loaded_loras applies those patches in float space, quantizes the result, and removes the now-redundant patches so they don't get applied a second time. Skip this and you can end up with LoRA effects silently doubled or, worse, core's generic patching disabling the fast INT8 path on the layers it touched.

The inputs and outputs that matter

• model - your already-loaded MODEL, from any stock loader.
• model_type - leave on auto unless you're experimenting; it selects the right exclusion preset for your architecture.
• outlier_method - none (fastest) or convrot (better quality, native-compatible) are the two you'll actually use.
• bake_loaded_loras - keep it on if you ran stock LoRA nodes before this one.
• runtime_backend - torch_int_mm (default, robust everywhere) vs triton (can be faster, more setup).

Output is a single MODEL, patched to INT8, ready to feed into a sampler, an INT8 Lazy Torch Compile node, or a Load LoRA INT8 node if you want to layer more LoRAs on afterward.

How to install it

Two options, same result:

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

You'll need a recent ComfyUI, an NVIDIA GPU with meaningful INT8 throughput, and a PyTorch build that matches your ComfyUI install. If you're on Windows and want the Triton runtime backend, you also need triton-windows matched to your PyTorch/CUDA build - the README's own tested combo is PyTorch 2.8.0+cu126 with triton-windows 3.4.0.post21. No model downloads are required for this node specifically; it works on whatever checkpoint you're already loading.

Common issues & troubleshooting

Put this node after stock Load LoRA, not before. The README is explicit about this, and it's the single most common way people get worse results than expected. Stock LoRA nodes applied after INT8 conversion can silently disable the fast quantized path on the layers they patch, because core's LoRA patching doesn't know about the Toolkit's INT8 layers.

Sudden VRAM spikes or an OOM that shouldn't happen. Some LoRA-order combinations briefly materialize a full-precision float tensor mid-conversion. On lower-VRAM cards this can look like a spike out of nowhere, even on a model that fits comfortably once sampling starts. If you hit this, double-check your node order matches the README's recommended chain (loader → stock LoRA → this node → sampler).

Quality looks off after quantizing. Try outlier_method=convrot instead of none - it's slower but the Hadamard rotation handles outlier activations better, and it's the option ComfyUI's own native INT8 format uses under the hood.

model_type=none produces bad output. That's expected - it skips the protective exclusion presets entirely. The README calls it out as "for experiments only." Stick with auto unless you're specifically testing an unsupported architecture.