Quantize Model

Quantization used to mean downloading somebody else's file and hoping they used a sane recipe. This node runs the recipe yourself, inside your graph: hand it a loaded diffusion model, pick a format, and it writes a quantized safetensors file and rebuilds the model from the result so you can sample it immediately. LoRAs applied before it get merged in at full precision first.

When it's actually worth it

Be honest about this one. If Comfy-Org already publishes an int8 convrot file for your model, download that - the node's like Comfy-Org option exists to reproduce it, not beat it. The genuine cases are narrower: you've stacked LoRAs on a base and want the merged result on disk, you're on a model nobody has quantized, or you want to shrink something without buying a bigger card.

The formats are the ones ComfyUI runs natively, which is what makes this useful rather than academic. int8 convrot is roughly half of bf16 with very little loss and it works on 20/30/40/50-series - including 30-series cards, which get no fp8 acceleration at all. fp8 e4m3fn wants a 40-series or newer. mxfp8 and nvfp4 are Blackwell territory and mostly interesting because NVFP4 is hardware-accelerated rather than emulated. w6a8 lands near 40% of the original size, w4a8 near 30% and is where you actually start seeing the loss.

What it does

It quantizes the model's linear layers, writes the state dict to a numbered safetensors in ComfyUI's output folder, then rebuilds a model from those weights via comfy.sd.load_diffusion_model_state_dict - that's how the model output is ready for a sampler straight away, and also why an unrecognisable result raises instead of failing later.

The layers, qkv, attention and scales menus are the "make it look like the official release" controls. layers picks which layers get quantized (repeated transformer blocks, or literally every linear layer for a smaller, slightly less faithful file). qkv matters if you use LoRAs: fused gives one combined projection as Comfy-Org ships it, separate gives three layers, which is what LoRAs for split projections expect. attention sets an attention kernel, and like Comfy-Org mirrors what their release does.

The inputs that matter

model - straight from Load Diffusion Model. Anything patched before this gets folded in, including LoRAs.

format - start with int8 convrot. It's the best quality-per-byte on hardware that isn't Blackwell.

filename_prefix - defaults to diffusion_models/quantized, written under ComfyUI's output folder as quantized_00001.safetensors. Empty this out to skip the file entirely and just get the in-memory model. To load the file later, move it into models/diffusion_models.

protect - the interesting one. Give it 0.1 and the worst tenth of layers by quantization error stay one step finer, which is a cheap way to stop w4a8 falling apart on a particular layer.

group_size and scales are advanced; leave them on defaults unless you're reproducing someone's published file exactly.

Output is model, quantized, plus the saved file. Note that the node is an output node - it will run and write even if nothing is wired downstream, and it caches like anything else, so changing nothing means no second file.

Installing it

ComfyUI Manager, search WAS Node Suite v3, restart. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui.git

ComfyUI 0.14.0+ and Python 3.10+. No pip packages - the quantization formats are ComfyUI's own. That's a real change from the pack's 2024 reputation, where the install pulled in a couple of dozen dependencies and could take your whole ComfyUI setup down with it.

Where it goes wrong

It needs the whole model in memory. You're quantizing a model you had to load first, so a 20 GB bf16 checkpoint needs to fit somewhere before it gets smaller. Quantize on the machine that can hold it, then move the file.

could not build the quantized weights back into a model that ComfyUI recognises. Usually a LoRA stack that patched keys the quantizer couldn't map back. Wire the model directly from Load Diffusion Model and re-apply the LoRAs after quantization.

LoRAs stop working on the saved file. You quantized with fused projections and your LoRA expects separate ones, or the other way round. Pick separate if you plan to keep layering LoRAs on the result.

A layer silently came out int8. If group_size doesn't divide a layer's width, that layer falls back to int8 convrot. Harmless, but it explains a w4a8 file that's bigger than you calculated.

Quantizing a model that already fit. If your card holds the bf16 or fp8 model comfortably, you're trading fidelity for nothing. People routinely report the speedup they were chasing came from removing --lowvram flags, not from a lower quant.