FSampler Advanced

The name isn't a lie for once. FSampler Advanced isn't another sampler that reshuffles the same math - it's an acceleration layer that skips whole model calls by predicting the noise the model would have output, then feeding that prediction into your existing sampler as if nothing happened. Swap it in for KSampler and you get roughly a quarter of your steps back, training-free: h2 mode cuts ~24–26% of model calls with parity on standard configs, and the aggressive adaptive mode can reach 40–60%+ - when conditions are right, which is doing real work, more on that below.

How the trick works

Diffusion sampling is a step-by-step ODE solve, and each step costs a full pass through the model to get a noise prediction (epsilon). FSampler's observation is that epsilon changes smoothly enough across steps that you can extrapolate it from the last few real calls. The node keeps a short history of real epsilons, and when it decides a step is safe it builds a polynomial fit - h2 is linear, h3 is Richardson extrapolation, h4 is cubic - and feeds the predicted epsilon into the unchanged sampler integrator (Euler, DPM++ 2M/2S, DDIM, LMS, and RES4LYF-family solvers like res_2m are all in the dropdown).

It doesn't immediately drift into noise because every prediction is validated (finite checks, magnitude clamp against history, cosine similarity against the last real epsilon) and scaled by a learned stabilizer L. Guard rails in protect_first_steps/protect_last_steps keep the composition-setting early steps and detail-finishing final steps honest. Adaptive mode goes further: it builds two predictions (h3 vs h2), compares their predicted next states, and only skips when the relative error is below a hardcoded tolerance, with anchors and a cap on consecutive skips to bound drift. Because everything is deterministic, a high-skip run lands close to the no-skip run on the same seed - iterate fast, keep one seed for the final render.

Two v1.5.0 toggles fix real failure modes. sigma_aware uses actual sigma values as coordinates for the Lagrange interpolation instead of assuming uniform step spacing - a genuine fix for non-uniform schedulers like karras, bong_tangent, or exponential. extrapolate_denoised predicts the model's clean-image estimate instead of epsilon, which is a smoother quantity to extrapolate. Both default off here (the simple FSampler node enables them); if your scheduler is anything but simple/normal, sigma_aware is the first thing I'd flip.

The inputs that actually matter

Most of the panel is the standard KSampler set - model, positive, negative, latent_image, seed, cfg, steps, scheduler, sampler - so a swap-in just works. Beyond those, three things drive the behavior:

• skip_mode - the speed dial. none is baseline (no skipping; run this first to sanity-check). h2/s2 is the recommended starting point (~24% fewer calls, safe); h3/s3 and h4/s4 are progressively more conservative; adaptive is the aggressive gate. In "hN/sK", N is the history behind the predictor, K is the calls before a skip.
• adaptive_mode - corrections applied on skipped steps: none, learning (the L stabilizer), grad_est, or learn+grad_est. Only matters when you're skipping; learn+grad_est is the best-quality option for aggressive patterns.
• skip_indices - manual override, e.g. "h2, 3, 4, 7". Skips exactly those steps (0-based) with the given predictor and ignores everything else. This is the low-step-count escape hatch: on a 5-step run you can't afford blind cadence skipping, but skipping only step 4 saves ~20% compute while preserving the steps that establish composition. Steps 0 and 1 are never skipped regardless.

The outputs are samples (LATENT - wire it into a VAE Decode like any KSampler) and metadata (STRING - a per-step diagnostics dump with sigma targets, epsilon norms, and [RISK] flags). If something goes wrong, the author asks for that metadata/verbose output on a GitHub issue; turn verbose on for the full per-step breakdown.

Installing it

cd ComfyUI/custom_nodes
git clone https://github.com/obisin/comfyui-FSampler
# restart ComfyUI

Or use ComfyUI Manager and search for ComfyUI-FSampler. No extra Python dependencies and no model downloads - the pack bundles its own copies of the k-diffusion / official / res4lyf sampling code so the skip layer wraps samplers without touching your ComfyUI install. It's GPL-3.0, worth knowing if you share graphs commercially.

Where people actually get burned

The pattern from real testing is consistent, and the author agrees: adaptive is aggressive and will not always produce anything usable. Testers saw 48–52% render-time cuts on Flux with Adaptive+Learning, alongside output one described as "deep fried"; the same combo on Hunyuan Video cut 39% but produced glow artifacts. Meanwhile h2/s2 gave a 26% cut with "minimal to no important visual changes" and a 16% cut on video. So: run skip_mode=none as a baseline, step up to h2/s2, and only chase adaptive if you're happy with what you see - and raise protect_first_steps/protect_last_steps if artifacts appear. Two honest caveats from the README: low-step workflows (<10 steps) barely benefit, and some sampler+scheduler combos produce nonsense even without skipping - blame the combo, not the node.