Phase-Based Frame Interpolation (2x)

Most frame-interpolation you'll meet in ComfyUI is RIFE or GIMM-VFI: big neural nets that need model downloads and a GPU that isn't already busy. This one is the odd one out. PhaseBasedFrameInterpolation is a pure classical algorithm - no model files, no VRAM, runs happily on the CPU - that takes a batch of frames and inserts one synthesized frame between every consecutive pair, turning N frames into 2N−1.

That's genuinely useful. Video generators like Wan or AnimateDiff usually spit out 16–24 choppy frames; doubling them to 30–60fps is the difference between "slideshow" and "video." Where the community normally reaches for RIFE for that job, this node is the option when you can't or won't spend the VRAM - or you just want to see what the algorithm can do without downloading anything.

How it works

The idea dates to a well-known 2016 writeup on phase-based frame interpolation, itself drawing on older steerable-pyramid work. The core claim: image structure lives in the phase of local frequencies, not the intensities. Blend intensities and moving edges get blurry and ghosted. Interpolate phase and they stay sharp.

Peek at the code and the implementation is faithful to that. Each frame goes RGB → CIE Lab. Only the luminance channel gets the fancy treatment - a Laplacian pyramid is built, each level is turned into a complex analytic signal via an FFT (a 2D Hilbert transform), and the per-pixel phase difference between the two frames is computed level by level. Phase differences wrap modulo 2π, so there's a coarse-to-fine unwrapping pass where each finer level is corrected against the upsampled coarser estimate. The interpolated frame then blends amplitude linearly but advances phase by α × Δφ, reconstructs by summing real parts across scales, and linearly blends the a/b chroma channels (your eyes forgive chroma artifacts far more easily). At α=0.5 you get the midpoint frame.

Honestly? The results are decent for slow, clean motion - which is exactly the assumption baked in. It's not going to beat RIFE on hard cases.

The inputs that matter

Only two, which is the whole appeal:

• images - an IMAGE batch of frames straight from a Load Video node. Wire that in.
• pyramid_levels (INT, 3–10, default 6) - the number of pyramid levels. More levels mean better phase unwrapping for larger motion, at the cost of speed. Leave it at 6 until you hit artifacts, then nudge up.

The single output, images, is the doubled frame batch (2N−1 frames) - feed it into a Save Video or Preview node.

Installation

ComfyUI Manager: search "PhaseFrameInterpolation" and install. Or manually:

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

Restart ComfyUI; it appears under video/interpolation. Dependencies are just numpy, scipy, and opencv-python - nothing heavy, no model files anywhere.

Gotchas

• The README lies (a little). It documents a video_path/output_video_path node that reads a video file directly. The shipped code was refactored to plain IMAGE-batch I/O, and the README never caught up. Trust the node in your UI: it takes frames, not a path.
• Playback duration. The node only doubles frames; it doesn't touch FPS. Set Save Video to 2× your input FPS, or the video plays back at half speed.
• It's slow. CPU-bound, and the README's own numbers - a 1-minute 1080p clip taking several minutes - are optimistic on modest hardware. Consider it for short clips.
• Where it breaks: large motion (more than ~a quarter of the frame width between frames) defeats the unwrapping, and occlusions blend rather than resolve. Those regions will soften. That's not a bug; it's the algorithm.

If you have a free GPU, RIFE remains the better default. If you don't - or you want an interpolation step that costs zero download - this is a refreshingly self-contained little node.