GapFiller (frame interpolate)

Somewhere between the name and the class is the honest version of this node: it looks at two frames, works out what moved in between, and draws the frames that should sit between them. Set multiplier to 2 and every pair of input frames becomes three. Set it to 4 and a 15-frame clip becomes 57. It's the whole-number sibling of the pack's other node, GapFiller (retime to fps) - same model, same knobs, but you tell it "make this N times longer" instead of "make this play at N fps."

You reach for it when your video moves like a slideshow. Generated video is the usual culprit: Wan and friends don't crank out 60 clean frames a second, and the standard pipeline is generate low, then smooth the motion and upscale. Doubling or quadrupling the frame count turns a stuttery clip into something you can actually watch, and it's the same trick people have been stacking on top of video restoration for years. Slow motion is the other half of the use case - feed it a normal clip at multiplier 4 and the result plays back at a quarter speed, buttery.

Set expectations before you fall in love. This is a v0.1 model trained in a few hours on a single GPU, and the author's own benchmark is blunt about it: quality is a tie with RIFE, not a win, and RIFE is far more parameter-efficient (5.4M params against GapFiller's 24M). The reason to use this over the RIFE node is ergonomics and controls, not a quality leap. Most pack READMEs don't tell you the metric table is basically noise; this one does.

How it works

The model is in the IFNet family (the architecture RIFE popularized): three coarse-to-fine stages estimate bidirectional optical flow plus a blend mask, both input frames get warped to the target time, the warped frames blend together, and a learned residual adds detail back on top. Warping rather than regressing pixels is what keeps output sharp - the sharp pixels already exist in the inputs, so the network just has to move them. It's fully convolutional and pads internally, so any resolution works.

Weights (96 MB) download automatically on first run. No API key, no external service - all local once the checkpoint is on disk.

Inputs and outputs that matter

The node takes a batch of frames and returns a batch of frames, so it slots into the middle of a video graph.

• images - a single IMAGE batch. Load your clip with VideoHelperSuite; the node does the rest.
• multiplier - 2 to 16, default 2. Output frames land at roughly input × multiplier.
• loop - the one optional input and the standout feature: it interpolates the last frame back to the first for a seamless loop. RIFE has nothing like this; if you make loops or GIFs, this is why you're here.
• ckpt_name - gapfiller_v1.pt, auto-downloaded on first run.

Then there are six inference controls (sharpness, blend_bias, flow_scale, scene_thresh, ensemble, scale_factor), all defaulted sensibly - a beginner can ignore them. The two worth touching early: flow_scale below 1 when motion is huge and things smear, and scene_thresh if your clip has hard cuts that morph ugly instead of cutting.

The output is a single IMAGE batch - same shape as the input, just longer. Wire it into a VideoHelperSuite save node and set the output fps, or the file plays too fast.

Installation

Same install as the rest of the pack. In ComfyUI Manager, search GapFiller and hit install, or from a terminal:

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

Restart ComfyUI and the nodes appear under the GapFiller category. Dependencies are light - torch>=2.0 and numpy, both already shipped by ComfyUI. The only download is the 96 MB checkpoint, and it fetches itself into ComfyUI/models/gapfiller/ on first run.

Common issues

• First run needs internet - the weights come from a GitHub release. If the download fails, grab gapfiller_v1.pt from the releases page and drop it into ComfyUI/models/gapfiller/ by hand.
• It needs a real batch - give it fewer than two frames and it just returns the input unchanged, no error. Load a proper clip, not a single frame.
• Motion artifacts are expected - it's a v0.1 model; large, fast motion is where flow-based interpolators smear. Drop flow_scale toward 0.7–0.8 and it handles it better.
• Don't forget the output fps - the node returns frames, not timing. Encode at the new frame rate or the math you just did is invisible.

If you're converting to a specific fps (say 16 → 60 for Wan), the retime node in this pack is the one you actually want - this node just multiplies.