ComfyUI Workflow Optimization: Speed Up Image Generation by 3×

Direct answer: ComfyUI workflow optimization means reducing the time and VRAM required to generate each image by choosing faster nodes, better samplers, and smarter resolution strategies. On an RTX 3090, a naive 50-step Euler a workflow at 1536×1536 can take 60+ seconds and 18 GB VRAM. An optimized 20-step DPM++ workflow at 1024×1024 with tiled upscaling takes 12 seconds and 10 GB VRAM. This guide covers every technique that matters.

Optimization techniques ranked by impact

Technique	Speedup	VRAM reduction	Quality impact
Reduce steps (50 → 20)	2.5×	None	Minimal with good sampler
Switch to DPM++ 2M Karras	1.3×	None	None
Enable xFormers / SDP	1.2×	10–15%	None
Use tiled VAE decode	1.5× at high res	40–50%	None if tile size ≥ 64
Batch multiple images	2–3× per image	+30% total	None
Use LCM / Turbo models (4–8 steps)	5–8×	None	Noticeable detail loss
Model offload (CPU ↔ GPU)	Slower per image	60–70%	None
FP16 / BF16 inference	1.5×	50%	None

Step 1: profile your current workflow

Before optimizing, find the bottleneck. In ComfyUI, enable timing by launching with --verbose or checking the browser console. The typical breakdown for a 512×512 image is:

Model loading: 2–5 seconds (one-time per session)
CLIP encoding: 0.1–0.3 seconds
Sampling (U-Net): 60–80% of total time
VAE decode: 10–20% of total time
Post-processing: negligible

If sampling dominates, reduce steps or switch samplers. If VAE decode is slow, enable tiling. If model loading repeats, keep the workflow alive between generations.

Step 2: choose the right sampler and steps

Samplers differ in convergence speed. For most workflows, DPM++ 2M Karras at 20–25 steps produces results indistinguishable from Euler a at 50 steps, in half the time. Some samplers like DPM++ SDE offer slightly better quality at the cost of speed. UniPC is another fast option for 15–20 steps.

Recommended defaults

Quality-first: DPM++ 2M Karras, 25 steps
Speed-first: DPM++ 2M Karras, 20 steps
Ultra-fast: LCM sampler, 4–8 steps (quality tradeoff)
SDXL: DPM++ 2M Karras, 30 steps (SDXL needs slightly more)

Step 3: enable xFormers or scaled dot-product attention

ComfyUI supports xFormers and PyTorch 2.0's nativescaled dot-product attention (SDP). xFormers reduces memory and speeds up the attention mechanism in the U-Net. To enable:

# In your ComfyUI startup script or command
python main.py --xformers

# Or for PyTorch 2.0+ SDP (often faster on newer GPUs)
python main.py --use-pytorch-cross-attention

On RTX 30-series and newer, SDP is often as fast as xFormers and requires no extra install. Test both on your GPU.

Step 4: use tiled VAE for high resolution

Generating at 1536×1536 or higher causes VAE decode to spike VRAM usage and slow down. Tiled VAE splits the latent into smaller tiles, decodes each, and reassembles. Enable it with the VAE Decode (Tiled) node or set tile size in settings.

Recommended tile sizes:
- 512×512 base: no tiling needed
- 1024×1024: tile size 64–96
- 1536×1536: tile size 64
- 2048×2048: tile size 32–64 (slower but prevents OOM)

Tiled decode at 2048×2048 is often faster than standard decode because it avoids memory thrashing. The visual difference is invisible at tile sizes of 64 or above.

Step 5: batch generation

Generating 4 images in a batch is faster than 4 separate generations because model weights stay loaded and sampling overhead is amortized. In ComfyUI, connect an Empty Latent Image node with batch size > 1, or use a Rebatch Latents node to process multiple prompts together.

Batch size is limited by VRAM. On a 24 GB RTX 3090:

SD 1.5 at 512×512: batch 8–12
SDXL at 1024×1024: batch 2–4
Flux at 1024×1024: batch 1–2

Step 6: use model offloading if VRAM is tight

If you have 12 GB VRAM or less, use the Load Checkpoint node with weight_dtype set to FP16 and enable --normalvram or --lowvram flags. These offload unused model layers to system RAM, trading speed for memory.

# For 8–12 GB cards
python main.py --normalvram

# For 6–8 GB cards
python main.py --lowvram

# For 4–6 GB cards
python main.py --novram

Step 7: optimize models and LoRAs

Use FP16 checkpoints instead of FP32. A 2 GB FP16 model loads faster and uses half the VRAM of a 4 GB FP32 variant. Most modern checkpoints are distributed in FP16 by default.

Merge frequently used LoRAs into the base model to avoid runtime merging overhead. Tools like merge_lora.py from the kohya-ss repo can bake LoRAs into checkpoints permanently.

Step 8: use LCM and Turbo for drafts

For rapid iteration, use SDXL Lightning or LCM LoRA. These produce acceptable preview images in 4–8 steps. Switch to a quality model at 25–30 steps for final output. The speed difference is 5–8×, making this the best workflow for prompt engineering and style exploration.

Before and after: a real workflow

Metric	Naive workflow	Optimized workflow
Resolution	1536×1536 direct	1024×1024 + hires fix 2×
Sampler	Euler a, 50 steps	DPM++ 2M Karras, 20 steps
VAE	Standard decode	Tiled VAE, tile 64
Attention	Default	xFormers enabled
Time per image	58 seconds	14 seconds
VRAM peak	18.4 GB	10.1 GB
Perceived quality	Baseline	Identical

Cost impact on GPU cloud

At 58 seconds per image on an RTX 3090 ($0.44/hr), generating 1,000 images costs $7.08 in GPU time. At 14 seconds per image, the same batch costs $1.71. Optimization alone saves 76% on compute costs. On higher-end GPUs like the A100, the absolute savings are larger.

Common mistakes

Generating at final resolution directly: Always generate at base resolution (512 or 1024) and upsample. It is faster and identical in quality.
Using 50+ steps out of habit: Modern samplers converge in 20–30 steps. Extra steps waste time with diminishing returns.
Ignoring VRAM limits: Workflow crashes from OOM cost more time than conservative tiling would have saved.
Not batching: Separate generations for each prompt reload the model repeatedly.
Using FP32 models: FP16 is faster, smaller, and visually identical.

Related guides

FAQs

Why is ComfyUI slower than Automatic1111?

It is not inherently slower, but default workflows often use unoptimized settings. With the same sampler, steps, and resolution, ComfyUI and A1111 are nearly identical in speed.

Does tiled VAE reduce image quality?

Not at tile sizes of 64 or larger. At 32, rare seam artifacts can appear. Use 64–96 for best results.

Can I optimize ComfyUI on a 12 GB GPU?

Yes. Use --normalvram, FP16 models, tiled VAE, and batch size 1. Generate at 512×512 and upscale.

What is the fastest sampler for quality?

DPM++ 2M Karras at 20–25 steps. UniPC at 15 steps is also excellent for speed.

Should I use LCM for final images?

Only if speed matters more than perfection. LCM at 4 steps is great for drafts. Final deliverables should use 20–30 steps with a standard sampler.

ComfyUI Workflow Optimization: Speed Up Generation by 3×