Dazzle KSampler Chain (DazzleNodes)

Most samplers are one-shot: noise in, image out. Dazzle KSampler Chain is the one that's designed to continue. Feed it the latent that a previous sampling run produced - complete with its internal state_info - and it carries on from where that run stopped, rather than starting fresh. It's the orchestrator pattern from RES4LYF's chains, ported under the Dazzle name.

Don't reach for this as your first sampler. It exists for workflows that deliberately split sampling into stages: run part of the trajectory with one sampler, then hand the intermediate state to a Chain node to finish (or continue further) with different settings. That's how people do multi-stage passes - coarse composition first, then a detail-focused finish - without decoding and re-encoding between stages.

How it works

The key trick is that the incoming LATENT carries state_info - a record of the sigma schedule and sampler state from the run that produced it. The Chain node reads the remaining sigmas straight out of that state instead of computing its own schedule from scratch. That's why steps isn't even on the widget list: the step count is derived from state_info['sigmas']. What you do set is steps_to_run - how many steps this link in the chain gets (-1 means run the whole remaining schedule). The other stage-relevant widget is sampler_mode, and here it's a two-way choice: resample (forward, continuing denoising) or unsample (reverse - walking the trajectory backward, the basis of the "unsampling" tricks people use to explore what a latent actually contains).

There's a nice bit of defensive engineering in the source: if the incoming state says it was unsampled and you're now resampling, it flips the sigma array so the continuation runs the right direction. You don't have to manage any of that - just be aware the node is actively reconciling directions for you.

The inputs that matter

• sampler_name - pick the solver for this link (default res_2m), independent of whatever ran before.
• steps_to_run - how far this link goes. -1 means "to the end."
• sampler_mode - resample vs unsample; default is resample.
• cfg - note the tooltip: negative values switch to channelwise CFG.
• latent_role - same five-way role selector as the plain DazzleKSampler, applied to how the latent is interpreted on chain continuation. auto is the right default.

Optional inputs are the standard model, positive, negative, sigmas (override), latent_image, plus guides and options. Outputs are the same triple as the main node: output (LATENT), denoised (LATENT), and options (OPTIONS).

Installing it

Same pack as the rest of the Dazzle samplers:

cd ComfyUI/custom_nodes
git clone https://github.com/DazzleNodes/ComfyUI-DazzleKSampler.git

Restart ComfyUI, and it appears under RES4LYF/samplers alongside its siblings. ComfyUI Manager users can search "Dazzle KSampler" instead. No pip dependencies or model files - the engine is pure Python over ComfyUI's torch.

Where people get burned

The classic trap: connecting a plain EmptyLatentImage and expecting the Chain to do something. Without state_info in the latent, there's no previous run to continue, and this node isn't a standalone starter - it's a middle link in a chain. If your workflow doesn't already produce a stateful latent from another Dazzle sampler, this node has nothing to continue. The other thing to keep in mind: because everything hinges on that internal state, Chain is the least "just swap it in" node in the pack. If you don't have a concrete multi-stage reason to use it, the plain DazzleKSampler will do the same job with fewer moving parts.