ComfyUI Samplers and Schedulers Explained: Which to Use for Every Model (2026)

The KSampler node in ComfyUI offers more than 40 samplers and 9 schedulers, plus steps, CFG and denoise. Most people leave them on whatever the template used, and that is often fine, until a new model gives blurry, burnt or noisy images and the fix is a single dropdown. This guide explains what every sampler and scheduler in current ComfyUI does, which ones are slow, which ones change the image every time, how steps, CFG, denoise and shift interact, and the settings that work for each model family, from SD 1.5 and SDXL to Flux, Qwen Image, MOSS-Image, Wan and MiniMax H3 video.

How Sampling Works in 60 Seconds

Every image or video starts as pure noise. At each step the model predicts what the clean image looks like, and the sampler uses that prediction to remove some of the noise. The scheduler decides how much noise is left after each step: lots of big early steps for composition, or more small late steps for fine detail. Put simply:

• Sampler = how each step is taken (the maths method).
• Scheduler = how the total denoising is split across the steps.
• Steps = how many times the model is asked.
• CFG = how strongly the result is pushed towards your prompt and away from the negative prompt.
• Denoise = how much of the starting image is replaced (1.0 = all of it).

The noise level at each step is called a sigma. The scheduler produces the list of sigmas; the sampler walks through them.

Best Settings by Model (Cheat Sheet)

Start here. Values are typical starting points from official templates, model cards and our own guides. When a model’s template or card gives different numbers, use those.

Model-specific guides with full settings: FLUX 3 Image Klein, MOSS-Image, Qwen Image 2.1 in 6 steps, Krea 2 in 3 steps, Fibo 2 and MiniMax H3 LoRAs.

Every Sampler Explained

This is the full list from the current ComfyUI source, grouped by type. “Cost” is how many times the model runs per step compared with euler. “Converges” means the image settles as you add steps instead of changing.

First-order samplers (fast, 1 model call per step)

Second-order and higher (better per step, slower per step)

Adaptive and special

• dpm_fast: DPM-Solver with a fixed schedule of its own.
• dpm_adaptive: chooses its own step count based on error, so it ignores your steps value and can be very slow.
• cfgpp_ud10_ab: an experimental CFG++ variant; see below.

The _gpu versions create the random noise on the GPU instead of the CPU. They are slightly faster, but the same seed gives a different image than the non-GPU version, and results can differ between GPU models.

Ancestral, SDE and “Converging” Samplers

Samplers with ancestral or sde in the name inject new random noise at every step. That has three effects:

• The image does not converge: 20 steps and 40 steps give noticeably different pictures, even with the same seed.
• They often look more detailed or more “alive”, and can fix the plastic look of some models.
• They are worse for workflows that need consistency, such as comparing settings, animation frames or reproducible results.

Converging samplers (euler, dpmpp_2m, uni_pc, deis, heun and so on) settle on one image; extra steps only refine it. Use them when you want predictable results or are tuning other settings.

The _cfg_pp Samplers

Samplers ending in _cfg_pp (euler_cfg_pp, euler_ancestral_cfg_pp, dpmpp_2m_cfg_pp, dpmpp_2s_ancestral_cfg_pp, res_multistep_cfg_pp, gradient_estimation_cfg_pp and others) use CFG++, a different way of applying guidance. They are designed for a much lower CFG, usually around 1 to 2. At a normal CFG of 7 they over-cook the image. Try them when a model looks oversaturated at normal CFG but weak at low CFG.

They have no effect on models run at CFG 1, because there is no guidance to change.

Every Scheduler Explained

Safe pairings: dpmpp_2m + karras for SD 1.5 and SDXL, euler + simple or euler + beta for flow models, lcm + sgm_uniform for LCM. A mismatched scheduler, such as karras on a Flux-family model, is one of the most common causes of grainy or noisy output.

How Many Steps?

• Base models with CFG: 20 to 30 for SD 1.5 and SDXL, 25 to 50 for large 2026 image models, 20 to 30 for video.
• Turbo, Lightning and distill LoRAs: exactly what the card says (3, 4, 6 or 8). More steps often makes them worse, not better.
• Second-order samplers (heun, dpm_2): about half the steps of euler for similar quality.
• Converging samplers stop improving after a point. If 30 and 50 steps look the same, use 30.
• Drafts: halve the steps to explore prompts, then render the keeper at full steps with the same seed (use a converging sampler for this).

CFG, Guidance and Negative Prompts

CFG (classifier-free guidance) runs the model twice per step, once with your prompt and once with the negative prompt (or empty), and pushes the result away from the negative. Higher CFG follows the prompt more strictly; too high burns colours and adds harsh contrast.

• CFG 1 turns guidance off. The negative prompt is ignored and each step is about twice as fast.
• Distilled models and speed LoRAs (Turbo, Lightning, distill, DMD) are trained for CFG 1. Raising it usually ruins the image.
• Guidance-distilled models such as Flux.1 dev take a separate “guidance” value (the FluxGuidance node, about 3.5) and run at CFG 1.
• Typical ranges: 5 to 8 for SD 1.5 and SDXL, about 3 for MOSS-Image, 5 for Fibo 2 Dev, 5 to 6 for Wan video.

If you need a negative prompt with a CFG 1 model, some workflows use NAG (normalized attention guidance) from the ComfyUI-NAG custom node pack instead of raising CFG.

Why Some Settings Are Twice as Slow

Generation time is roughly proportional to the number of times the model runs. That number is:

model calls = steps x (2 if CFG is above 1, otherwise 1) x sampler cost

So SDXL at 30 steps with CFG and dpmpp_2m is 60 calls, but the same settings with heun are about 120. A distilled model at CFG 1 and 8 steps is just 8 calls, which is why speed LoRAs feel so much faster.

Estimate for a 16 GB card like the RTX 5080: if one model call on a 1024×1024 image takes about 0.15 seconds, 60 calls is about 9 seconds and 8 calls is about 1.2 seconds, plus text encoding and VAE decode. This is an estimate, not a measured result.

Denoise for img2img, Inpainting and Upscaling

Denoise sets how much of the input image is replaced. With an Empty Latent Image it should be 1.0. With an input image or a second “hires fix” pass:

With denoise below 1, ComfyUI only runs the last part of the schedule. At 20 steps and denoise 0.5, roughly 10 steps actually run. For video upscales, too low a denoise is the usual reason a second pass adds no detail; our H3 2K/4K upscale guide shows a working two-pass setup.

KSamplerAdvanced uses start_at_step and end_at_step instead of denoise. Starting at step 10 of 20 is the same idea as denoise 0.5, and splitting one generation between two models (for example a high-noise and a low-noise video model) works by giving each one part of the steps.

Shift (ModelSampling Nodes)

Flow-matching models often have a shift value, set with nodes such as ModelSamplingSD3, ModelSamplingAuraFlow or ModelSamplingFlux placed between the model loader and the sampler. Shift moves more of the steps towards high noise levels:

• Higher shift: more effort on overall structure and motion. Helps at high resolutions and in video, where a low shift can give duplicated limbs, broken layouts or messy motion.
• Lower shift: more effort on fine detail. Can look sharper at small sizes but less coherent at large ones.

Use the template’s value first (for example about 8 for Wan video and 5 for MOSS-Image). Many distill LoRAs say to remove the shift node entirely because their schedule is already built in.

Custom Sigmas and Advanced Sampler Nodes

KSampler bundles everything into one node. For more control, ComfyUI splits it into parts:

• SamplerCustom or SamplerCustomAdvanced: takes a sampler, sigmas, a guider and noise as separate inputs.
• KSamplerSelect: picks the sampler.
• BasicScheduler: makes sigmas from a scheduler name, steps and denoise.
• AlignYourStepsScheduler: NVIDIA’s optimized schedules for SD 1.5, SDXL and SVD, good at 10 steps.
• ManualSigmas: type the exact sigma list a LoRA was trained with. Several 2026 speed LoRAs need this, and a generic schedule gives worse results. See our Pruna 6-step guide and Pika H3 Flex guide for examples.
• CFGGuider and BasicGuider: CFGGuider applies CFG with a negative prompt; BasicGuider is the CFG 1 equivalent.
• SplitSigmas: divides a schedule into two parts, for two-pass or two-model workflows.

Fixing Bad Results

For crashes and red error boxes rather than bad images, see ComfyUI errors and fixes.

FAQ

What is the best sampler in ComfyUI?

There is no single best. euler with simple is the standard for modern flow models, and dpmpp_2m with karras is the standard for SD 1.5 and SDXL. Start with those and only change if you see a problem.

What is the difference between a sampler and a scheduler?

The sampler is the method used for each denoising step. The scheduler decides how much noise is removed at each step.

Is euler_ancestral better than euler?

Not better, just different. It adds noise each step, which gives softer and more varied images but does not converge. Use euler when you need repeatable results.

Why does my Turbo LoRA look worse with more steps?

Distilled models are trained for a fixed number of steps and CFG 1. Use the exact values from the LoRA card.

Does the sampler affect speed?

Yes. Second-order samplers like heun, dpm_2, dpmpp_sde and dpmpp_2s_ancestral run the model about twice per step. dpm_adaptive ignores your step count and can be very slow.

Does the seed give the same image with a different sampler?

No. The seed sets the starting noise, but each sampler takes a different path from it.

Final Thoughts

For most people, two pairings cover almost everything: euler with simple (or beta) for modern flow models, and dpmpp_2m with karras for SD 1.5 and SDXL. Match steps and CFG to the model card, keep CFG at 1 for anything distilled, and remember that CFG and second-order samplers each double the work per step. When an image looks wrong, check CFG, the scheduler and the step count first, in that order.

More ComfyUI reference guides:

• ComfyUI Command Line Arguments
• ComfyUI Model Folder Cheat Sheet
• ComfyUI Errors and Fixes
• Best Open Source Text-to-Image Models in 2026

Sources

• ComfyUI source: comfy/samplers.py (sampler and scheduler lists)
• ComfyUI source: comfy/k_diffusion/sampling.py (sampler implementations)
• DPM-Solver paper and DPM-Solver++ paper
• Karras et al., Elucidating the Design Space of Diffusion Models
• CFG++ paper