KSampler Gradually Adding More Denoise (efficient)

This is the odd one out in the ComfyUI Frame Interpolation pack. Everything else in there invents frames between your existing ones - this is a sampler. It lives in the pack's others category, not the VFI one, and it's a leftover utility from the animation workflows the pack was born in. If you came here looking for frame interpolation, this isn't the node you want; grab FILM VFI, GMFSS Fortuna VFI, or one of the other VFI nodes instead.

What it actually does is run a KSampler while ramping the denoise strength up as it goes. Instead of one fixed denoise value for the whole run, it starts low and steps higher. That's the trick behind certain progressive img2img and animation loops, where you want the first pass to barely touch the image and later passes to reshape it more aggressively - the "gradually adding more denoise" that gives the node its mouthful of a name.

How it works

A normal KSampler denoises a latent by one fixed amount. This one takes a starting denoise and an increment, and increases the effective denoise across the run according to the schedule you set. The start_denoise, denoise_increment, and denoise_increment_steps inputs define that ramp: where it begins, how much it climbs each time, and over how many steps.

The "(efficient)" in the name is a nod to the Efficiency Nodes convention - this node passes its inputs straight back out. It hands you the same MODEL, positive and negative CONDITIONING, LATENT, and VAE on its outputs so you can daisy-chain another sampler or a decode without re-wiring everything from scratch. It's a marked output node, so it'll trigger a run on its own.

The inputs that matter

Most of these are the standard KSampler controls you already know - model, positive, negative, latent_image, seed, steps, cfg, sampler_name, and scheduler all behave exactly as they do on the core sampler. The three that make this node different:

• start_denoise (FLOAT, default 0) - where the denoise ramp begins. Low means the first pass barely changes the latent.
• denoise_increment (FLOAT, default 0.1) - how much denoise gets added at each step of the ramp. This is the "gradually more" dial.
• denoise_increment_steps (INT, default 20) - how many steps the increment is applied over, controlling how steep the ramp is.

There's an optional optional_vae passthrough so the VAE rides along to whatever's downstream.

The outputs are MODEL, CONDITIONING+, CONDITIONING-, LATENT, and VAE - the pass-through set. The LATENT is your actual result; the rest exist so the node slots cleanly into an Efficiency-style chain.

Installing it

It comes with the whole ComfyUI Frame Interpolation pack - you don't install this node on its own.

• ComfyUI Manager - search ComfyUI Frame Interpolation, install, restart.
• Manual - cd ComfyUI/custom_nodes && git clone https://github.com/Fannovel16/ComfyUI-Frame-Interpolation, then run python install.py (Linux, in your ComfyUI venv) or install.bat (Windows), and restart.

Unlike the VFI nodes, this one loads no interpolation checkpoint of its own - it uses whatever diffusion model you wire into its model input.

Common issues

Honestly, the most common issue with this node is picking it by accident when you wanted an interpolator. If your goal is smoother video, close this and open a ... VFI node.

If you are using it deliberately: the pass-through outputs trip people up. The CONDITIONING+ / CONDITIONING- and MODEL/VAE outputs are the same ones you fed in - they're there for chaining, not because the node transformed them. Wire the LATENT onward for your result. And because the denoise ramps upward, an overly aggressive denoise_increment will blow past your source image entirely in the later steps; if the output stops resembling your input, pull the increment down.