⚡ Rife Tensorrt

This is the node that actually does the work in the RIFE TensorRT pack. Feed it a stack of frames plus a loaded TensorRT engine and it hands you back two or four times as many frames, in between the ones you gave it. That's slow-mo, that's smoothing a choppy 12fps AI video up to something watchable, that's turning a 24fps render into 48 or 60. If you've ever waited on the plain PyTorch RIFE inside ComfyUI-Frame-Interpolation, this is the "I'm not waiting" version.

RIFE's trick is optical flow: it figures out where each pixel moved between two frames, warps both toward the midpoint, and blends a synthetic in-between at whatever timestep you ask for. The TensorRT rewrite is the same math compiled into an NVIDIA engine, and the speed difference is the whole point. Community verdict is basically "not the most accurate VFI, but nothing this fast comes close" - if you need the best possible quality you reach for something like GIMM-VFI, and if you need a 2000-frame clip interpolated before lunch, you reach for this.

The inputs that matter

• frames - a batch of IMAGE tensors, exactly what a video loader like VideoHelperSuite (VHS) outputs. Batch them all in: the node walks consecutive pairs.
• rife_trt_model - the RIFE_TRT_MODEL handle from the pack's Load Rife Tensorrt Model node. Don't skip that step and don't expect this node to work on its own.
• multiplier - default 2. Each input interval gets multiplier - 1 inserted frames, so 2 doubles the clip, 4 quadruples it. Integer, min 1 (which just passes the frames through untouched).
• clear_cache_after_n_frames - default 100. The node flushes CUDA cache every N frames to stop long clips from eating your VRAM. Long video OOMing? Drop it to 25 or 10.

The output

A single IMAGE - your original frames plus the interpolated ones, (N-1) * multiplier + 1 of them total. Wire it to a video saver (VHS Video Combine, Save Animated WebP, whatever you normally use) and you're done. Since the input and output are both plain IMAGE batches, you can chain this anywhere a video pipeline expects frames - and yes, it plays nicely before a video upscaler, since interpolation and temporal upscaling are different jobs.

Under the hood

For each consecutive frame pair, the node preprocesses to CHW, runs the engine on a CUDA stream with a timestep of 1/multiplier, 2/multiplier, and so on, then stacks everything back in order. It clears the cache on the schedule above and shows a progress bar, which is nice because on a 2000-frame clip you will watch it for a while - though the author's H100 numbers (45fps at 512x512 with 2x) give a sense of how fast the engine itself is on real hardware.

Install

Same as the pack, since it ships in it: ComfyUI Manager → search "ComfyUI Rife TensorRT", or

cd ComfyUI/custom_nodes
git clone https://github.com/yuvraj108c/ComfyUI-Rife-Tensorrt
cd ComfyUI-Rife-Tensorrt
pip install -r requirements.txt

Dependencies are just einops, colored, polygraphy, and tensorrt. Models download and engines build automatically on first use of the load node.

Where people get burned

The classic failure is feeding frames outside the engine's resolution profile - the engine is built for anything from 256x256 up to 3840x3840, so an oddball like 300x300 usually works but something past 4K won't. Engine building on Windows historically required a CUDA toolkit; the 2026 rewrite removed that dependency. And if the first run hangs for minutes, that's the engine building, not a dead node - it's cached afterward, so you only pay once. Remember it's non-commercial licensed (CC BY-NC-SA 4.0), and keep an eye on your VRAM on long clips - that cache-clearing knob exists because it's needed.