anla1234-itachi/comfyui-quant-bench

ComfyUI quantization benchmarks

Which file should you load in ComfyUI on your GPU? Each benchmark here runs the same prompts with every native ComfyUI option for one model on three GPU generations, and measures speed, VRAM and how close each image stays to bf16. All images, per-image data and the scripts are included.

About: these benchmarks are made by the author of PyTorch Precision Converter, an open-source CLI that converts PyTorch and safetensors models to fp16, bf16, fp8 or ComfyUI fp8_scaled, turns FP8 models back into BF16 on a CPU, and merges or splits shards (pip install pytorch-precision-converter). It made the fp8_scaled files tested here. If the benchmarks help you, a ⭐ on GitHub helps other people find them.

MOSS-Image SFT (2026-10-29)

Speed: median seconds per 1024×1024 image (25 steps) and the speed-up against bf16 on the same GPU. LPIPS: distance from the bf16 image with the same prompt and seed (lower is closer, 0 is identical).

Format	A10G (Ampere, ~RTX 3090)	L40S (Ada, ~RTX 4090)	RTX PRO 6000 (Blackwell, ~RTX 5090)	Peak VRAM
bf16 (reference)	44.9 s	15.4 s	8.4 s	10.7 GB
bf16 + loader fp8_e4m3fn	0.96× · LPIPS 0.199	1.00× · 0.170	0.92× · 0.209	5.7 GB
bf16 + loader fp8_e4m3fn_fast	0.96× · 0.199	1.26× · 0.168	1.26× · 0.211	5.7 GB
fp8_scaled	0.97× · 0.137	1.27× · 0.113	1.28× · 0.120	6.0 GB
int8_convrot (Comfy-Org)	1.84× · 0.087	2.05× · 0.060	1.82× · 0.079	5.8 GB
NVFP4 mix	1.45× · 0.109	1.51× · 0.086	2.03× · 0.121	5.0 GB

• Comfy-Org's int8_convrot file is the best choice on all three GPU generations: 1.8–2.05× faster than bf16 and the closest to bf16, including on Ampere (RTX 30-class), where it was 1.84× faster.
• NVFP4 is the fastest on Blackwell (2.03×) but drifts further from bf16 than int8. On Ampere and Ada it is slower than int8.
• The loader's fp8_e4m3fn weight dtype, a plain cast of the bf16 file, is the weakest option: the most drift, and no speed-up unless you pick fp8_e4m3fn_fast on Ada or Blackwell. On Ampere the two give identical results.
• A scaled fp8 file stays closer to bf16 than the plain cast at the same speed, but int8_convrot beats it on every GPU.
• FP8 gives no speed-up on Ampere, which has no FP8 hardware; it only halves VRAM.
• unsloth's MOSS-Image GGUF doesn't load in native ComfyUI with ComfyUI-GGUF (unknown architecture moss_image); its card points to OpenMOSS's own ComfyUI plugin.

Update, 2026-10-29: int8 attention, plain int8 and a T4. Comfy-Org's int8_convrot file also carries 42 per-layer settings (comfy_attention.config, {"attention": "comfy_kitchen_int8"}) that switch ComfyUI to int8 attention, and the NVFP4 mix file carries the same 42; bf16, the loader fp8 options and fp8_scaled ran ComfyUI's default attention. A follow-up run measured the effect with a plain int8 file (int8 without ConvRot, made with PyTorch Precision Converter 2.3), with and without those settings. On the A10G, L40S and RTX PRO 6000, int8 attention made it 6–10% faster, so int8_convrot's lead over fp8_scaled comes mostly from its int8 weights. On a T4 it made it 2.3× faster.

Median seconds per image and median LPIPS against bf16 (same software, prompts and seeds as above):

GPU	bf16	int8_convrot (Comfy-Org)	int8 without ConvRot	int8 without ConvRot, default attention
T4 (Turing, ~RTX 20-class)	671.7 s	107.7 s · 0.079	98.1 s · 0.076	230.3 s · 0.090
A10G	45.0 s	24.5 s · 0.069	30.1 s · 0.104	31.9 s · 0.083
L40S	15.4 s	7.7 s · 0.045	9.6 s · 0.072	10.2 s · 0.051
RTX PRO 6000	8.45 s	4.63 s · 0.067	5.40 s · 0.092	5.96 s · 0.057

• On a T4, int8 without ConvRot was the fastest file: 9% less time per image than int8_convrot, about as close to bf16. On the newer GPUs it took 17–25% longer and drifted further, so int8_convrot stays the pick there.
• A T4 has no bf16 hardware, and ComfyUI runs MOSS-Image in fp32 on it by default: 11 minutes per image. --fp16-unet made it 5.5× faster with almost no drift (median LPIPS 0.011); the int8 files were 6.2× and 6.8× faster; fp8_scaled was no faster than bf16 (0.99×) and only saved VRAM.
• The follow-up's bf16 and int8_convrot times on the A10G, L40S and RTX PRO 6000 match the table above within 3%. Data, images and scripts: moss-image/2026-10-29-followup/.

Four of the 12 prompts on the L40S, same seed, with each format's LPIPS against bf16.

Files tested

Format	File
bf16	Comfy-Org/MOSS-Image diffusion_models/moss_image_sft_bf16.safetensors
loader fp8 options	the same bf16 file with UNETLoader weight_dtype set to fp8_e4m3fn or fp8_e4m3fn_fast
fp8_scaled	made from the bf16 file with precision-convert moss_image_sft_bf16.safetensors -p fp8_scaled --like moss_image_sft_int8_convrot.safetensors (PyTorch Precision Converter 2.1.0): per-tensor scaled FP8 on the same 168 layers as the int8 file
int8_convrot	Comfy-Org/MOSS-Image diffusion_models/moss_image_sft_int8_convrot.safetensors, the default in ComfyUI's template
NVFP4 mix	BennyDaBall/MOSS-Image-SFT-NVFP4 moss_image_sft_nvfp4.safetensors (NVFP4 and int8 layers)
GGUF Q8_0	unsloth/MOSS-Image-SFT-GGUF MOSS-Image-SFT-Q8_0.gguf (did not load)

Method

• Software: ComfyUI 0df1646 (2026-10-28), comfy-kitchen 0.2.40, PyTorch 2.15.0+cu132, NVIDIA driver 595.112.07, ComfyUI-GGUF 6ea2651.
• Settings from ComfyUI's MOSS-Image text-to-image template: 1024×1024, 25 steps, CFG 2.5, er_sde sampler, simple scheduler, empty negative prompt, flux2-vae_small VAE. 12 prompts, seeds 1000–1011.
• Text encoder: qwen3.5_9b_bf16 for every format. Each prompt is encoded once and the encoder is unloaded, so time and memory cover only the diffusion model.
• Code path: ComfyUI's own loader, sampler and VAE-decode functions (the ones behind UNETLoader, KSampler and VAEDecode), called in one Python process under torch.inference_mode(), as ComfyUI's executor does.
• Speed: median of images 2–12 for each format; image 1 includes loading and warm-up. Between images, times varied by up to 0.2% on the A10G and RTX PRO 6000 and by up to 5% on the L40S.
• Peak VRAM: torch.cuda.max_memory_allocated() during sampling: the diffusion model and its activations, without the CUDA context.
• Quality: LPIPS (AlexNet), SSIM and PSNR between each image and the bf16 image with the same prompt and seed, on the same GPU.
• Hardware: AWS g5.4xlarge (A10G 24 GB), g6e.2xlarge (L40S 48 GB) and g7e.2xlarge (RTX PRO 6000 Blackwell Server Edition 96 GB). These are data-center versions of the consumer chips (GA102, AD102, GB202) with lower clocks, so compare ratios within a GPU rather than absolute seconds against a gaming card.
• T4: AWS g4dn.12xlarge, four T4s at their 70 W limit. Formats ran split across the four GPUs, with int8 and int8_convrot paired on the same GPUs and prompts; rerunning each alone matched within 0.1%. The first image of each part is left out of the speed median.

Limitations

• One model and one sampler setting. The template's er_sde sampler adds noise at each step, so small numeric differences grow over 25 steps. LPIPS here includes that drift and varies a lot between prompts: on the fisherman portrait (prompt 1) on the RTX PRO 6000, fp8_scaled is at 0.035 and int8_convrot at 0.169.
• One image per prompt and format.
• Speed with other attention backends, launch flags, batch sizes or resolutions may differ.
• int8_convrot and NVFP4 mix ran with the int8 attention their files switch on, and the other formats with ComfyUI's default attention (see the update above).

Files

• moss-image/2026-10-29/summary.csv: the table above, machine-readable.
• moss-image/2026-10-29/results/<gpu>.json: one row per image (times, VRAM, LPIPS, SSIM, PSNR, loader warnings).
• moss-image/2026-10-29/env/<gpu>.json: versions and settings.
• moss-image/2026-10-29/images/<gpu>/<format>/<nn>.png: all 216 images.
• moss-image/2026-10-29/prompts.json: the 12 prompts.
• scripts/: the machine setup (setup.sh, run.sh), the benchmark (bench.py, prompts.json) and the report builder, exactly as they ran.
• moss-image/2026-10-29-followup/: the follow-up in the same layout (summary.csv with median LPIPS too, results/, env/, images/, prompts.json; results/t4-solo.json is the T4's timing control) and its scripts in scripts/ (gpus/ for the A10G, L40S and RTX PRO 6000, t4/ for the T4, and a README with the order they ran in). Formats: int8 was made with precision-convert moss_image_sft_bf16.safetensors -p int8 --like moss_image_sft_int8_convrot.safetensors, int8_noattn is the same file without the 42 attention settings, and bf16_fp16 is the bf16 file with ComfyUI's --fp16-unet.

Reproduce

On Ubuntu 24.04 with an NVIDIA GPU and a driver that supports CUDA 13.2 (the scripts assume /home/ubuntu):

bash scripts/setup.sh    # PyTorch, ComfyUI 0df1646, the model files from Hugging Face, the fp8_scaled conversion
unset LD_LIBRARY_PATH    # if system CUDA libraries shadow PyTorch's bundled cuDNN
python scripts/bench.py --out out

License and credits

• Results, images and text: CC BY 4.0. Scripts: MIT (scripts/LICENSE, moss-image/2026-10-29-followup/scripts/LICENSE).
• MOSS-Image by the OpenMOSS team (Apache-2.0). Files by Comfy-Org, BennyDaBall and unsloth (Apache-2.0). This dataset contains no model weights.
• Benchmark by angelolamonaca, author of PyTorch Precision Converter.