RIFE Multiplier

What it is

Frame interpolation nodes - the RIFE family, GIMM-VFI, and their cousins - don't take "make it 60 fps". They take a multiplier: 2×, 4×, 8×, meaning how many new frames to synthesize between each existing pair. RIFE Multiplier is the calculator that converts "my video is 16 fps and I want 60" into the integer that an interpolation node actually accepts, plus the fps you'll really get.

It's a conversion node for a conversion node. Video generators run at low frame rates (Wan and LTX commonly output 16 fps), and the path to smooth, high-fps video runs through interpolation. The math isn't hard, but it's fiddly in exactly the way that invites off-by-one mistakes - which, with interpolation, means a rejected run or a multiplier that silently does nothing.

How it works

Two inputs, two outputs, one formula: multiplier = round(target_fps / source_fps), floored at 1, and actual_fps = source_fps × multiplier. Feed it 16 source and 60 target, and you get 4× and 64 fps (4×16). Feed it 24 and 60, and you get round(2.5) = 2× with 48 fps actual - close to target but not exact, which is why the node bothers to tell you the actual fps instead of pretending.

The important behavior is in the tooltip, and it's the thing that'll save you a confusing error: the multiplier is at least 1, and a 1× multiplier means no interpolation happens. Some interpolation nodes, like GIMM-VFI, actively reject a 1× multiplier. So if your target is under 2× your source - say 24 → 30 fps - this node will dutifully report 1×, and your interpolation node may refuse to run. The rule of thumb: for actual frame synthesis, target at least 2× the source.

The inputs that matter

• source_fps - your input's frame rate. For an image batch rather than a video, set this to the intended playback rate of the frames.
• target_fps - the fps you're aiming for after interpolation.

Outputs:

• multiplier - the integer to feed the interpolation node (always ≥ 1).
• actual_fps - source × multiplier, what you'll actually end up with.

When you'd use it

In any video pipeline that interpolates. A typical chain: generate frames at 16 fps → RIFE Multiplier computes 4× → interpolation node synthesizes the new frames → Save Video writes at 64 fps. It also sits nicely alongside the pack's batch-extend-with-RIFE node, which uses interpolation to extend frame sequences. If your target fps isn't an exact multiple of the source, this node is what keeps the arithmetic honest.

Installing it

Part of ComfyUI_Eclipse:

cd ComfyUI/custom_nodes
git clone https://github.com/r-vage/ComfyUI_Eclipse
pip install -r ComfyUI_Eclipse/requirements.txt

then restart, or install via Manager (search "Eclipse"). And the usual pack lineage note: formerly RvTools_v2, legacy nodes gone as of v4.0.0 - migrate old workflows with the bundled tool.

Common issues

The failure to watch for is the quiet one: a target less than 2× the source rounds to 1×, and interpolation nodes either refuse or do nothing, while your video just looks unchanged and you wonder what's wrong. Check the reported multiplier before you run. And remember actual_fps may not equal target_fps - if you need exactly 60 fps, pick a source and target that divide cleanly, or accept the rounded result this node tells you about.