TJS Sampler (Truncated Jump Sampling)

TJS Sampler is a drop-in replacement for the plain KSampler that runs only part of the denoising trajectory, then asks the model to jump straight to the end. The idea: a diffusion or flow-matching model already predicts a clean x0 (the denoised latent) at every intermediate step, so why march all the way down the noise ladder when the model can tell you where it lands? Truncated Jump Sampling cuts your steps from K to roughly gamma * K, training-free, no new model files.

It comes from a research pack (hdfhssg/ComfyUI_TJS) that's new enough to have essentially zero community footprint - the commits are from July 2026 and nothing about it has surfaced on Reddit yet. Read the caveats at the bottom before you trust it for a deadline.

How it works

You set a full step budget K and an early-exit ratio gamma. The node computes k* = ceil(gamma * K), samples normally from sigma[0] down to sigma[k*], then makes one final call to decode the model's endpoint prediction at that exit point. The latent_x0 output is that prediction - feed it to VAE Decode and you're done.

One implementation detail matters here, because it's the difference between "saves time" and "saves nothing": the node appends a 0 to the truncated sigma schedule so the endpoint decode happens inside the same sampling call, not as a second sampler invocation. Early builds ran a separate sample_custom(sigmas=[sigma*, 0]) and ate a full pipeline setup per extra forward pass; the 2026-07-13 rewrite fixed that by capturing both denoised and the current state x with a k-diffusion callback in a single pass. That's why the math below holds up.

Inputs that matter

• total_steps - your full budget K, the number of steps you'd use in a normal KSampler.
• early_exit_gamma - the dial. 0.6 means "run about 60% of the trajectory, then jump." Lower is faster and riskier.
• cfg, sampler_name, scheduler - same knobs as KSampler; the sampler runs the truncated portion, so an already low-step-friendly setup (e.g. Euler on a flow model) behaves best.
• model_type - auto / diffusion / flow. Purely informational logging; start with auto.
• denoise (optional) - an img2img-style strength if you want it, otherwise leave it.

Everything else (seed, positive, negative, latent_image) is exactly what you'd wire into a normal sampler.

The outputs

You'll actually use latent_x0 → VAE Decode. The other five are diagnostics: latent_xt is the raw latent at the exit point (noisier than it looks - don't decode it unless you want a muddy preview), and k_star, nfe_used, nfe_saving_pct, sigma_at_exit tell you what actually happened. Example from the README: K=30, gamma=0.6 → k*=18 → 19 NFE, about 37% saved.

Install

No Python dependencies, no model downloads - just the node. Either grab it through ComfyUI Manager (search "ComfyUI_TJS") or:

cd ComfyUI/custom_nodes
git clone https://github.com/hdfhssg/ComfyUI_TJS

Then restart ComfyUI.

The honest caveats

• gamma = 1.0 saves nothing. By design the node takes a full-schedule fast path identical to stock KSampler, so don't run it at 1.0 expecting magic.
• Quality drops as gamma drops. An early-exit latent is still noisy, and the endpoint guess can't fully repair it. The README's FID-vs-NFE charts show the tradeoff; 0.6 is a reasonable start, and things get visibly rougher below ~0.4.
• This is experimental. Tested models include SDXL, SD3.5M, Z-Image-Turbo, Anima, Krea2, LTX-2B, FLUX.2-Klein, and Qwen-Image-Edit - a solid spread - but there's no community lore to lean on when something looks off, and the pack cites a 2026 arXiv paper ("x-Prediction Is All You Need") that's too fresh for anyone to have stress-tested.

It's genuinely clever, and the single-call implementation means the win is real. Just treat it as a speed experiment you verify against your normal sampler, not a free lunch.