Skip to content
,

How to Speed Up ComfyUI: 7 Proven Fixes Ranked (2026)

9–14 minutes
Woman in a modern brick loft with a gaming PC holding a card reading FASTER, hook 2-10x faster ComfyUI

ComfyUI is already one of the fastest ways to run image and video models locally, but most setups leave a lot of speed on the table.

The right model format, one attention package, a few launch flags and a smarter sampler setup can easily cut your render times in half, often much more, without buying a new GPU.

This guide ranks every speed-up by how much it helps and how hard it is, from two-minute wins to the bigger changes. Every flag here is checked against ComfyUI’s current cli_args.py, so you are not copying options that no longer exist.

TL;DR

  • Biggest win: fewer steps. A Lightning, Turbo or distilled model at 4-8 steps is 3-10x faster than 30-50 steps.
  • Second biggest: a model that fits in your VRAM. Use fp8, GGUF or NVFP4 (RTX 50) versions so nothing spills to system RAM.
  • Free speed on NVIDIA: install SageAttention and launch with --use-sage-attention; try --fast too.
  • Keep ComfyUI and PyTorch current. New releases regularly add faster kernels and better memory handling.
  • Put models on an NVMe SSD so loading and swapping models takes seconds, not minutes.

New to ComfyUI? My ComfyUI beginner guide covers install, models, nodes and fixes in one place.

First, Find Where the Time Goes

Before you change anything, run your workflow twice and watch the terminal. The second run matters more, because the first one includes loading models from disk.

  • The sampler line shows something like 20/20 [00:14<00:00, 1.40it/s]. That is the sampling speed. Write down the it/s (or s/it for video models).
  • “Prompt executed in X seconds” is the total. If it is much bigger than the sampler time, the rest is model loading, text encoding, VAE decode or upscaling.
  • Watch VRAM in Task Manager (Performance, GPU, Dedicated memory) or with nvidia-smi. If dedicated memory is full and “shared GPU memory” is rising, the model is spilling to system RAM. That is the number one cause of slow renders.

Now you know which part to fix: slow sampling (steps, attention, model size), slow loading (disk, RAM) or slow decode (VAE tiling, resolution).

Every Speed-Up Ranked

Change Typical gain Effort Quality cost
Lightning / Turbo / distilled model or LoRA 3-10x Low Small, model-dependent
Model fits in VRAM (fp8 / GGUF / NVFP4) 2-10x when it was spilling Low Very small at fp8 or Q8
SageAttention Often 20-50% on large models and video Medium Usually none visible
--fast Up to ~20-30% on supported GPUs Low Small, test it
Update ComfyUI + PyTorch + driver Varies, sometimes large Low None
Lower resolution, then upscale 2-4x Low Depends on upscaler
Models on NVMe SSD Loading 3-10x faster Low None
Previews off or low-cost Small Low None

Gains depend a lot on your GPU, model and resolution, so treat the numbers as ranges, not promises. Always compare it/s before and after each change.

1. Use Fewer Steps

Sampling time grows almost exactly with step count. Going from 30 steps to 6 is roughly 5x faster, and no flag or package can match that. Modern models make this easy:

  • Distilled models: many popular models have official fast versions, such as Flux Schnell, SDXL Turbo and Lightning, and Z-Image Turbo. They are trained to work in 1-8 steps.
  • Lightning LoRAs: for models like Qwen-Image and Wan video, Lightning LoRAs cut sampling to 4-8 steps on top of the normal model. See my Qwen-Image 2.1 Lightning guide.
  • One-step models: NitroFusion2 for Z-Image Turbo makes images in 1-2 steps.

Important: fast models need the right settings. Most want CFG 1.0 (which also skips the negative prompt pass, another near-2x saving) and a specific sampler and scheduler, often euler or lcm with simple or sgm_uniform. Using normal settings (CFG 7, 30 steps) with a distilled model gives burnt, over-sharpened images. Check the model card.

Even with normal models, many workflows use more steps than they need. Try 20 instead of 30 with dpmpp_2m and karras, and compare side by side with the same seed.

2. Make the Model Fit in VRAM

When a model does not fit in VRAM, ComfyUI offloads part of it to system RAM and streams it back for every step. That works, but it can be several times slower. The fix is a smaller version of the same model:

Format Size vs fp16 Speed Best for
fp16 / bf16 100% Baseline GPUs with plenty of VRAM
fp8 (e4m3fn, scaled) ~50% Same or faster; fastest on RTX 40/50 with fp8 compute 12-16 GB cards
GGUF Q8 / Q6 / Q5 / Q4 ~53% / 41% / 35% / 28% A little slower per step than fp8, but much faster than spilling 8-12 GB cards, very large models
NVFP4 ~25-30% Fast on RTX 50 (Blackwell) with a recent cu130 build RTX 50 series

A few tips:

  • Load GGUF files with the GGUF loader nodes, not the normal checkpoint loader. My ComfyUI GGUF guide covers install and which quant to pick.
  • Do not forget the text encoder. A full fp16 T5-XXL or Qwen text encoder can be 9-16 GB on its own. An fp8 or GGUF version saves a lot of VRAM.
  • On RTX 50 cards, a ComfyUI build with PyTorch for CUDA 12.8 or newer is required, and NVFP4 needs the CUDA 13 (cu130) build. See my RTX 50 series setup guide.
  • Not sure how much VRAM a model needs? Check how much VRAM you need for AI.

3. Install SageAttention

Attention is the most expensive part of modern image and video models. SageAttention is a drop-in replacement that uses quantized attention kernels and is much faster on NVIDIA GPUs, especially for video models like Wan and big image models at high resolution.

  1. Install Triton: on Windows that is the triton-windows package; on Linux it comes with PyTorch.
  2. Install the sageattention package that matches your Python, PyTorch and CUDA version. Prebuilt Windows wheels exist for common combinations.
  3. Add --use-sage-attention to your launch command, or use a node such as KJNodes “Patch Sage Attention” to turn it on per workflow.
  4. Restart and check the start-up log. It should say it is using sage attention.

The Windows install is the fiddly part, so I wrote a full step-by-step guide: install SageAttention on Windows for ComfyUI. If you get black images or errors after enabling it, remove the flag; a mismatched wheel is the usual cause.

4. Launch Flags That Help

Add flags to the end of your launch line, for example in run_nvidia_gpu.bat for the portable build, or in Server Config settings in ComfyUI Desktop. These are the ones that matter for speed:

Flag What it does When to use
--fast Turns on test optimizations: fp16 accumulation, fp8 matrix multiply, cuBLAS ops and cuDNN autotune. You can list only some, e.g. --fast fp16_accumulation RTX 30/40/50. First run is slower while autotune tests kernels. Check quality.
--use-sage-attention Uses SageAttention for attention After installing sageattention
--use-flash-attention Uses FlashAttention instead If you have flash-attn installed and no Sage
--highvram Keeps models in VRAM instead of unloading them after use Only with lots of spare VRAM. It also turns off dynamic VRAM.
--reserve-vram 1.5 Keeps some GB free for Windows, the browser and other apps If the desktop stutters or you get random out-of-memory errors
--preview-method latent2rgb Low-cost previews during sampling If you use heavy TAESD previews and want a little speed back
--fast-disk Loads and offloads from disk instead of unpinned RAM Fast NVMe drive with limited RAM. Test it.

Two things have changed in recent ComfyUI versions that old guides miss:

  • Dynamic VRAM and async offload are on by default on NVIDIA. ComfyUI now manages VRAM well on its own, so --lowvram does nothing when dynamic VRAM is active. Do not add old low-VRAM flags out of habit.
  • RAM-pressure caching is the default. --cache-lru N keeps more node results for faster re-runs at the cost of RAM; --cache-none saves memory but re-runs everything, which is slower.

The full list with every option explained is in my ComfyUI command line arguments guide. On RTX 30 and 40 cards, also see GPU Unlock for faster bf16.

5. Update ComfyUI, PyTorch and Drivers

ComfyUI releases often add faster code paths: better memory handling, new fused kernels, support for fp8 and NVFP4 compute. Running a six-month-old version can cost you real speed.

Update with the Manager, the update folder scripts in the portable build, or the built-in updater in ComfyUI Desktop. My how to update ComfyUI guide covers each install type.

  • PyTorch: newer versions are usually faster, especially on new GPUs. The portable build ships a recent one; for manual installs, upgrade within the CUDA version your build uses.
  • NVIDIA driver: keep it reasonably current. RTX 50 cards need a recent driver for CUDA 12.8 and 13.
  • Make sure the GPU is actually used. If generation is extremely slow and the GPU is idle, you may have a CPU-only PyTorch. See Torch not compiled with CUDA enabled.

6. Workflow Habits That Save Time

  • ComfyUI only re-runs what changed. If you only change the seed, the text encoder and model loading are skipped. Keep text, model and LoRA fixed while you explore seeds, and changes become very quick.
  • Generate small, then upscale. Make drafts at the model’s native size (about 1 megapixel for SDXL and Flux), pick the best, then upscale only that one. Rendering at 2048×2048 directly is about 4x the work and often looks worse. My RelayVSR x2 guide shows a fast upscaler for video.
  • Use the right batch size. A batch of 4 is often faster per image than 4 single runs, if it fits in VRAM. If it spills, go back to 1.
  • Use tiled VAE decode for large images and video. It keeps VRAM low so the decode does not spill, which can be faster at high resolution.
  • Turn off nodes you do not need. Bypass (Ctrl+B) face detailers, upscalers and preview branches while you are exploring.
  • Try speed-focused node packs. Caching nodes like TeaCache or First Block Cache skip repeated work in video and Flux models. My ComfyUI SPEED for image models guide covers one of the newest.

7. Storage, RAM and Windows Settings

  • Keep models on an NVMe SSD. A 20 GB model loads in seconds from NVMe, but can take minutes from a hard drive. This matters most when you switch models often.
  • Have enough system RAM. 32 GB is a good minimum for Flux and video models, 64 GB or more if you use big video models or offload. If Windows starts swapping to the page file, everything slows down.
  • Close other GPU apps. Browsers with hardware acceleration, games, video players and other AI tools all take VRAM.
  • Windows “CUDA Sysmem Fallback Policy”: in the NVIDIA Control Panel you can set it to “Prefer No Sysmem Fallback”. You then get an out-of-memory error instead of a silent slowdown, which makes the problem easier to spot. See CUDA out of memory fix if you hit that.
  • Power mode: on laptops, plug in and use the best performance mode. Battery mode can halve GPU speed.

What Does Not Help

  • xformers on modern setups. PyTorch’s built-in attention is as fast for most models now. SageAttention is the upgrade worth making.
  • Old low-VRAM flags like --lowvram or --novram on a card with enough VRAM. They can only make things slower.
  • Too many custom nodes. They do not slow sampling much, but a huge pile of them slows start-up and causes conflicts. Remove packs you do not use.
  • Overclocking for big gains. A small memory overclock may give a few percent; not worth the crashes during long video renders.

Best Setup by GPU

GPU Recommended setup
8 GB (RTX 3060 Ti, 4060) GGUF Q4-Q5 models and text encoders, Lightning/Turbo models, SageAttention, 1 MP drafts
12 GB (RTX 3060, 4070) fp8 or GGUF Q6-Q8, SageAttention, --fast, Lightning LoRAs for video
16 GB (RTX 4080, 5070 Ti, 5080) fp8 for most models, NVFP4 on RTX 50, SageAttention, --fast
24-32 GB (RTX 3090, 4090, 5090) fp16/fp8 freely, SageAttention, --fast, bigger batches; consider --highvram if you switch models rarely

Two GPUs? ComfyUI runs one workflow on one GPU, but you can start a second ComfyUI on the other card with --cuda-device 1 --port 8189 and render two jobs at once.

If you want more nodes to speed up your workflows, see my list of must-have ComfyUI custom nodes.

FAQ

Why is my first run always slower?

The first run loads models from disk and, with --fast, tests kernels for autotune. Judge speed on the second run.

Does SageAttention lower quality?

In most tests the difference is not visible. If you see artifacts with one model, turn it off for that workflow with a patch node instead of the global flag.

Is fp8 worse than fp16?

Slightly, but for most image and video models the difference is very hard to see. GGUF Q8 is very close to fp16; Q4 shows more loss.

Should I use –highvram?

Only if your models fit easily in VRAM with room to spare. On most cards the default dynamic VRAM handling is the better choice.

Is ComfyUI faster than Forge or Automatic1111?

For the same model and settings, ComfyUI is usually as fast or faster, and it gets support for new models and optimizations first.

Sources

Free weekly email

Get new AI guides every week

One short weekly email with our newest local AI, ComfyUI and AI tool guides. No spam, no pop-ups, just the good stuff.

Free. Unsubscribe anytime in one click. We only use your email to send this newsletter. See our privacy policy.

Woman in a modern brick loft with a gaming PC holding a card reading FASTER, hook 2-10x faster ComfyUI