GapFiller (retime to fps)

Here's the problem this node exists to delete. 24 → 60 fps is a 2.5x conversion. 16 → 60 fps - which you hit constantly with Wan - is 3.75x. And the RIFE node in ComfyUI only multiplies by whole numbers, so to reach 60 you had to overshoot (5x up to 120 and discard half, or 4x to 64 and resample unevenly back down), then feed the wreckage into a filter that drops frames. It works, in the way that changing a tire with a crowbar works.

GapFiller (retime to fps) skips the arithmetic entirely. You give it the source frame rate and the target frame rate; it generates every output frame at exactly the moment that target rate needs. No over-generation, no discard pass, no integer-multiplier restriction. This is the node in the pack most people actually want.

The wider workflow context is the same story the interpolation half of this pack tells: the standard production path for generated video is produce at a low frame rate, smooth the motion, then upscale. Retime is that smoothing step generalized to any target - not just "double it" but "make this precisely 60 fps," or the other direction entirely: set target_fps way above src_fps and you've built slow motion without touching a single playback setting.

How it works

The mechanism is neat and worth knowing because it explains why it's fast. The node walks the output timeline, and for each output frame computes its true position in source time: t = (i / target_fps) * src_fps. When that position lands on a real source frame (within a hair of a whole number), it reuses that frame untouched - no synthesis wasted. Only the genuinely in-between positions get run through the model, which is the same flow-based IFNet interpolator as the sibling node: estimate bidirectional optical flow, warp both frames to time t, blend, add a learned detail residual. It pads internally, so resolution is a non-issue.

Inputs and outputs that matter

• images - a single IMAGE batch, loaded via VideoHelperSuite.
• src_fps - default 24, range 1–240. This is the one to get right. Wan clips are commonly 16; if you feed it the wrong source rate, every interpolation is at the wrong moment and you get drift or stutter.
• target_fps - default 60, range 1–240. What you want out. These are floats, so purists can do 23.976 → 60.
• ckpt_name - gapfiller_v1.pt, auto-downloaded on first run (96 MB into ComfyUI/models/gapfiller/).

The six shared controls (sharpness, blend_bias, flow_scale, scene_thresh, ensemble, scale_factor) are all defaulted sensibly - leave them alone unless you hit a specific artifact. Note there's no loop input here; that trick belongs to the interpolate node.

Output is a single IMAGE batch with the new frame count. The critical detail: the node returns frames, not timing - you have to encode the result at target_fps in your save node, or you'll get a file that plays at the wrong speed and all the work was for nothing.

Installation

Identical to the pack's other node. ComfyUI Manager → search GapFiller → install, restart, and both nodes appear under the GapFiller category. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/KernelPanicKitten/ComfyUI-GapFiller

Dependencies are genuinely light - torch>=2.0 and numpy, which ComfyUI already has. The only big download is the checkpoint, and it fetches itself on first run.

Common issues

• First run needs internet - the weights download from a GitHub release. If that fails, put gapfiller_v1.pt from the releases page into ComfyUI/models/gapfiller/ manually.
• Wrong src_fps is the #1 cause of "why does this stutter" - double-check what your generator actually outputs before blaming the node.
• Encode at target_fps - this is the classic trap. The node hands you frames; if your video save node writes them at the source rate, the output plays too fast.
• Set expectations on quality - the author's own benchmark says this is a tie with RIFE, not a win, and it's a v0.1 checkpoint. Use it for the direct retiming and the extra controls; if you only need a plain 2x, the battle-tested RIFE nodes are the safer default today.

If you don't need an exact fps and just want "make it smoother by an even multiple," the interpolate node in this pack is the simpler tool - this one shines when the math isn't a whole number, which is most of the time.