Dazzle KSampler (DazzleNodes)

If you've copied a workflow and been told to set the sampler to res_2m and the scheduler to beta57, those names come from here. Dazzle KSampler is a drop-in replacement for the stock KSampler built on the RES4LYF sampling engine - the pack that quietly became where sampler tuning lives for flow-matching models - with one genuinely different trick bolted on: it can take your noise as an input instead of always inventing it from a seed.Stock ComfyUI samplers generate noise from a seed, period. Want to influence composition through the noise itself - fill patterns, image-shaped noise, spectrally blended textures from an upstream node? Tough luck; the seed-driven path overwrites it. DazzleKSampler closes that gap: when the incoming latent carries a shaped-noise payload, the sampler uses it verbatim. When it doesn't, it behaves exactly like a normal KSampler.

How it works

Two things make this node. First, the engine: 100+ RES4LYF RK methods and schedulers in one dropdown, defaulting to res_2m + beta57. If you're on any flow-matching model (Flux, Qwen-Image, Wan, Z-Image, Anima), that's the modern shortlist - Karras and exponential are known to fail on those architectures, and beta57 is the schedule people name when they post settings. If you're on SD 1.5/SDXL, the honest advice is that this pack buys you little; DPM++ 2M Karras is still your default.

Second, the latent_role widget, which controls how the input LATENT is interpreted. That's the DazzleNodes addition and the reason to reach for this node:

• auto (default) - inspect the dict and dispatch. This is right for almost every workflow.
• noise - use the upstream tensor as the initial noise at sigma_max; the init slot is zeroed.
• latent_image - standard img2img: samples are the init, noise comes from the seed.
• noise+latent_image - layered: noise from the upstream noise key, init from samples.
• seed_driven - true txt2img: zero init, noise from seed. Ignores upstream flags.

The companion protocol is a four-shape contract for what an upstream node can stuff in the LATENT socket: pure init, pure noise (with use_as_noise: True), layered (init + separate noise key), or empty. SmartResCalc, the sibling DazzleNodes pack, produces the shaped-noise shapes; a stock EmptyLatentImage produces the empty shape, which falls through to seed-driven noise by design.

The inputs and outputs that matter

A beginner sets three things and leaves the rest alone:

• latent_role - auto unless you have a specific reason to force a path.
• eta - the per-step ancestral noise budget. This is the big one for determinism: set eta = 0 and, with latent_role = noise, the seed becomes a dead input and the output is fully determined by your upstream noise tensor. Verified bit-identical across seeds in the project's own tests.
• noise_all - a master selector for the noise spectrum (gaussian by default; brown/pink are smoother and painterly, blue/violet are grainier). Set it to custom if you want to fiddle the three noise_type_* sub-widgets independently. Leave it at gaussian until you have a reason.

Wire model, positive, negative, and latent_image in exactly like a stock KSampler, and you get three outputs: output (LATENT, feed to a VAE Decode), denoised (the clean latent estimate before the last noise injection - handy for hi-res fix and img2img chains), and options (an OPTIONS object for RES4LYF-style parameter propagation downstream).

Installing it

ComfyUI Manager is the easy path - search "Dazzle KSampler" and install. Manually:

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

Restart ComfyUI. Nodes appear under RES4LYF/samplers (not a DazzleNodes menu - there's an open issue to move them). No pip dependencies and no model files to download; the engine is pure Python over ComfyUI's torch. One optional extra: install dazzle-comfy-plasma-fast if you want the DazNoise structured-noise options in the dropdowns. License is AGPL-3.0, inherited from RES4LYF.

Where people get burned

The two failure modes I've seen come from misreading latent_role. First: you wire up shaped noise upstream, nothing changes, and the seed still visibly drives everything. That usually means you're on a Shape A or D dict - the upstream node wasn't set to produce a use_as_noise latent (stock EmptyLatentImage and fill_type = black both fall through), so you're quietly in seed-driven mode. Check the console; the node prints mismatch and dispatch warnings on every run. Second: you expected full upstream determinism and the seed still matters. That's expected - latent_role only controls the initial noise tensor; per-step SDE noise is always seed-driven. That's exactly what eta = 0 exists for.

One honest caveat before you go deep: this pack is essentially invisible in community discussion - it's a new, low-profile fork. Its reputation rides on RES4LYF, which is genuinely mainstream, and the DazzleNodes-specific bits (noise passthrough, the role system) are young alpha software. Treat the exotic features as experimental and use res_2m + beta57 + eta = 0 as your safe lane.