🧪 X0 Accumulator (Experimental)

Every diffusion sampler does something quietly wasteful: at each step the model makes a full denoised prediction - its best guess at the clean image at that noise level - and then the sampler throws that guess away, keeping only the running latent and finally the last step's output. BoyoExperimentalRichardson, flagged with the 🧪 name X0 Accumulator, is a meta-sampler that catches those predictions before they're discarded, weights them, and blends them back into the final result. Same model, same steps, but the final latent now carries detail from the whole trajectory instead of just the end.

Here's the mechanism, concretely. You feed it any existing SAMPLER object (from KSamplerSelect or another experimental node). It runs your base sampler but installs its own callback that captures the denoised (x0) prediction at every step. When sampling finishes, it stacks all those predictions, applies a weighting curve, sums them into a single accumulated latent, and mixes it with the normal final output by blend_strength:

output = (1 - blend_strength) * final_output + blend_strength * accumulated_x0

The three settings that matter:

• weighting - how the captured predictions are weighted. exponential (default) makes late, detail-rich steps dominate; linear ramps smoothly from early to late; uniform weights everything equally (the safe, subtle starting point); late_only uses only the final tail_steps steps.
• blend_strength - how much of the accumulation to mix in. 0.0 bypasses the node entirely (pure passthrough of your base sampler), 0.35 is the recommended start, 1.0 means the accumulated latent replaces the standard output completely.
• tail_steps - how many steps late_only considers. Ignored in other modes.

The output is a sampler you wire the same way you'd wire KSamplerSelect: KSamplerSelect → BoyoExperimentalRichardson → SamplerCustomAdvanced. It needs a model that exposes x0 predictions via the callback (any standard ComfyUI epsilon, v, or flow-prediction model does).

The honest take

The name is aspirational. Real Richardson extrapolation is a specific numerical technique for combining coarse and fine step results; this node is a weighted average of x0 guesses, which is a different thing. Don't read the name as a promise of rigor - read it as "experimental quality-flavoring."

It's also not a magic button. If your sampler is already producing clean output, accumulating more x0 averages in can soften or shift it. Start at blend_strength 0.35 with uniform weighting, compare against 0.0 on the same seed, then tune. And because it captures predictions via callback, if a base sampler doesn't fire callbacks it logs a warning and falls back to returning the unmodified output - which is a graceful failure, not a crash.

Installing it

It's part of Boyonodes - search Boyonodes in ComfyUI Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/DragonDiffusionbyBoyo/Boyonodes

Restart. This node needs torch and nothing else from the pack's requirement list; it wraps ComfyUI's own sampling internals. If the whole pack fails to load, check the console traceback for whichever audio/video module borked the import - that's the pack's recurring failure mode, and it's never this node's fault.

Treat it as a flavor knob on top of samplers you already trust. It's experimental by design: A/B test it, and bypass it (blend_strength 0) the moment it stops earning its place.