SparkDiffusion CrossDistill Sigmas (experimental)

The rest of this pack runs in an isolated runtime and hands you an MP4. This node runs inside ComfyUI, imports torch for about four lines, and gives you a SIGMAS tensor. And the author is unusually blunt about what that does and doesn't get you: the node's own description says "Schedule only - no RoLA sparse attention." Which is to say, this is not SparkDiffusion acceleration. It's the timestep schedule from CrossDistill, exposed so you can drive a native ComfyUI sampler with it.

That honesty is the useful part. Because "SparkDiffusion" as a package is three things stacked - RoLA sparse attention, the few-step CrossDistill schedule, and FP8 - and only the middle one is extractable into a plain ComfyUI graph. You can have the exact step spacing without any of the speedup, and it's worth knowing which half you're holding.

What it actually outputs

SparkDiffusion's distillation lives in rectified-flow time, where t = 1 is pure noise and t = 0 is the clean sample. Upstream derives its knots from older TrigFlow values via rf = sin(t) / (cos(t) + sin(t)), and this node transcribes those constants from upstream's inference entry points. The output is a list of steps + 1 values: the start time, then the intermediate knots, ending at 0.

The start time isn't hardcoded. It's sigma_max / (sigma_max + 1), which is why the node exposes sigma_max (FLOAT, default 1600, range 1 to 1,000,000). Feel the formula: at the default you get 1600/1601 ≈ 0.9994, so the first sigma is essentially 1.0. Push sigma_max higher and it creeps closer to 1. Drop it to something small and you'd start the run from a much noisier-looking value with less time left to clean up.

steps is an enum of strings - "1", "2", "3", "4", "8" - and it maps to a hardcoded knot list. Three steps runs (0.933781, 0.852895); four adds 0.608979; eight has a longer list. There's a reason the schedule is a lookup table and not an interpolation: these checkpoints were distilled at those exact timesteps, and the spread between them is what the student model was trained to jump. Four isn't "three steps, denser" - it's a different trajectory.

Using it

The mechanism the schedule reproduces is a plain Euler step on a flow model: x = noise * t[0], then a loop of v = net(x, t_cur * 1000); x = x + (t_next - t_cur) * v. To match upstream you need a flow model at shift = 1.0 with the multiplier at 1000, the Euler sampler, and CFG 1.0 - CFG-free is the point of the distillation, so wiring a positive and negative prompt and leaving guidance at 7 will not reproduce these steps.

Wire sigmas into anything that takes a SIGMAS input, typically right before a custom-sampling node so you replace the sampler's own schedule with this one.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/hiroki-abe-58/ComfyUI-SparkDiffusion

or Manager → search SparkDiffusion → restart. This is the one node in the pack with no runtime setup at all - no separate venv, no model download, no GPUs required to place it. It's pure Python plus a tensor construction.

Where people get burned

The trap is the obvious one, and it's the reason the category says experimental. You drop this in expecting SparkDiffusion speeds on a regular Wan workflow and get… regularity. No RoLA, no sparse attention, no FP8, no fused kernels, no compiled DiT - the model is dense and slow and you've only changed when it takes its steps. Also note "1" step is in the enum because upstream supports it, not because it's a good idea on a checkpoint you didn't distil for it. And if you were hoping to bolt this onto your own LoRA stack, that's a separate road: the pack's real acceleration path replaces Wan's attention entirely, which no native sampler can do.