RIFE GPU Fast (Lee)

Frame interpolation is how you turn a 16 fps AI video into a smooth 32 fps one without re-generating it, and RIFE is the classic model for it. The catch: in ComfyUI, RIFE has a reputation for being oddly slow - people post about it maxing out 64 GB of RAM while the GPU sits there doing nothing. That's not RIFE being heavy. That's the usual VFI node pushing frame-pairs through one at a time, shuttling each pair to the GPU and flushing the CUDA cache every few frames. The forward pass is tiny, so the card idles between steps.

RIFE GPU Fast (Lee) is the fix for exactly that. It's the single node in Smai-Lee's Lee-RIFE pack, and its whole reason to exist is batching: feed it your whole frame sequence and it runs the interpolation in GPU-sized batches instead of a serial crawl.

How it works

RIFE - Real-Time Intermediate Flow Estimation, from Zhewei Huang et al. - is an optical-flow model. Give it two frames, it estimates the motion between them and synthesizes the frames that would sit in between. This node runs RIFE v4.7 (rife49.pth, bundled right in the repo, ~21 MB) through its IFNet architecture.

The clever bit is the batching. It takes your frames tensor, chops it into consecutive pairs, and pushes batch_size pairs through the model at once with one pass per intermediate timestep. The whole sequence stays in RAM while only each batch chunk touches the GPU. On out-of-memory it automatically halves the batch and retries, so it scales down to a 6 GB card without you touching anything.

Two quality knobs are worth knowing before you tune anything else:

• ensemble (on by default) - runs a forward pass and a time-reversed pass and averages them. RIFE's real bidirectional ensemble. Cleaner motion, roughly double the work. The obvious thing to turn off if you need speed.
• precision (fp16 default) - visually identical to fp32 for interpolation at about 2× the speed on modern NVIDIA cards. Leave it unless you're chasing bit-faithful output.

The inputs that matter

You wire your frames into frames (an IMAGE tensor - the standard output of a video model or AnimateDiff), then:

• multiplier - output frames per input frame. 2 doubles the frame rate. Range 1–16.
• batch_size - frame-pairs per GPU batch, default 16. Higher uses the GPU better; it lowers itself on OOM, so don't stress about it.
• scale_factor - internal flow scale. Default 1.0. Only touch it (0.5 or 0.25) at very high resolutions to save memory.
• ckpt_name - defaults to the bundled rife49.pth. It also accepts rife47.pth (same architecture) if you drop one in the models folder.

The single output is an IMAGE tensor with multiplier × N frames - 81 frames at 15 fps becomes 162 at 30 fps, same duration. Wire it straight into your video-encoder/save node, and set that node's fps to input_fps × multiplier, or your video plays at the wrong speed.

Install

Easiest way is ComfyUI Manager: search Lee-RIFE and install. Or do it by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/Smai-Lee/Lee-RIFE

Restart ComfyUI completely - the process, not just the browser tab. The node appears as "RIFE GPU Fast (Lee)" under Lee/RIFE.

The nice part: no extra pip installs. The requirements file is deliberately empty so nothing overwrites ComfyUI's CUDA build of PyTorch - a real hazard with some VFI packs. The weights ship with the repo (no LFS needed). You need an NVIDIA GPU with ComfyUI's CUDA PyTorch; it won't run CPU-only.

Gotchas

• First run, check the console. You should see [ComfyUI-Lee-RIFE] loaded rife49.pth (arch 4.7) on cuda:0 / torch.float16. If the model can't be found, you'll get a FileNotFoundError telling you to place the weights - copy rife49.pth from an existing comfyui-frame-interpolation/ckpts/rife/ install or grab it from Practical-RIFE.
• It dies on a long video. Each intermediate frame is held in RAM, so a very long high-res clip still eats memory. The auto-halving only saves VRAM, not system RAM - for long clips, split them first.
• Wrong playback speed is the classic mistake, and it's a node-setting issue, not the interpolation's fault: set your output fps to input × multiplier.

Is it the highest-quality interpolator in ComfyUI? No - the modern GIMM-VFI and friends are generally prettier for that final polish pass. This is the fast, free, zero-dependency one you reach for when you just want the footage smoother.

Credits

Lee-RIFE's own code is MIT (© 2026 Smai-Lee); the model and the vendored rife_arch.py come from RIFE/Practical-RIFE and Fannovel16's ComfyUI-Frame-Interpolation, with full notices in THIRD-PARTY-NOTICES.md.