🐇 RIFE VFI Custom Timing

The plain interpolate-by-multiple node is great until you realize every in-between frame is landing at the same evenly spaced spot - and real motion isn't even. RIFE VFI Custom Timing is the same interpolation engine, but you get to say where each new frame lands between the source pair. That one change turns a "smooth it out" tool into a motion-design tool: ease in, ease out, clamp the range so motion never sticks too close to a frame, or hand it an exact list of blend positions and get frame-perfect control.

It's the node that makes slow-motion ramps, speed-ups, and - the pack's signature move - seamless video loops possible. WhiteRabbit was built around looping video, and custom timing is the seam that holds a loop together: instead of letting a transition drift through frames at uniform speed, you pin where each synthesized frame lands so the loop's last→first jump feels like a normal step.

How it works

For every pair of frames, the node generates multiplier in-between frames, and a timing function maps each one to a position t between 0 (the first frame) and 1 (the next). The t_mode control picks the function:

• linear - the default, evenly spaced.
• gamma_in / gamma_out / gamma_in_out - easing modes where t_gamma sets the strength. Higher gamma = more easing. Handy for ramps: ease-in feels like acceleration, ease-out feels like settling.
• bounded_linear - clamps the positions to t_min–t_max. This is the anti-freeze tool: if frames keep sticking at the same spot, tighten the range so motion never sits too close to a source frame.
• custom_list - ignores the schedule entirely and reads exact positions from the custom_t_list_csv field, a comma-separated list like 0.18,0.41,0.66.

The whole point of custom_list is that you don't have to invent the list yourself - the pack's RIFE Seam Timing Analyzer computes one for you and hands it over ready to paste.

The inputs that matter

• frames - your clip.
• multiplier - how many new frames per pair. 0 is a passthrough (no new frames), which is genuinely useful for previewing timing without burning GPU time.
• t_mode and t_gamma - the easing controls above.
• custom_t_list_csv - the override list. Takes comma- or space-separated values in 0–1, clamps and sorts them for you.
• optional_interpolation_states - skip in-between frames for selected pairs (scene cuts) while keeping the timing of the rest.
• ckpt_name - RIFE 4.7/4.9 default, auto-downloaded into models/frame_interpolation/ on first use; scale_factor and ensemble are the usual quality/speed pair.

Installing it

WhiteRabbit is a one-time install for all 14 of its nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/Artificial-Sweetener/comfyui-WhiteRabbit
cd comfyui-WhiteRabbit
python -m pip install -r requirements.txt

Or hit ComfyUI Manager → search "WhiteRabbit" → install, then restart. The pack's only extra pip dependency is torchlanc; it's written for ComfyUI's v3 node API, so keep ComfyUI current.

Where people get burned

• Empty or wrong custom_list. If your list has more values than multiplier creates, extras get ignored; if it's empty, custom_list falls back to the schedule. Paste the analyzer's output verbatim and you're fine.
• t_gamma at the default of 1. That's basically linear. You need to raise it (2–4 is a good starting range) before you'll see easing.
• Clamping yourself into a corner. bounded_linear with a tight t_min/t_max produces a speed bump you may not want - it's there to prevent frame-sticking, not to create motion.

For a one-off smooth-out job, use the simpler multiply node. For anything where timing is the point - loops, ramps, beats - this is the one you'll actually reach for.