ComfyUI Frame Interpolation: RIFE vs FILM, Models and FPS Math

Quick answer

ComfyUI frame interpolation no longer needs a custom node. Since release v0.20.1 (2026-04-27), ComfyUI ships two built-in nodes: Load Frame Interpolation Model and Run Frame Interpolation Model. They run RIFE or FILM models that you put in ComfyUI/models/frame_interpolation/, and Comfy-Org publishes the files in its Comfy-Org/frame_interpolation repository on Hugging Face. The bundled template is called "Frame Interpolation: FILM or RIFE".

The older route still works: the ComfyUI-Frame-Interpolation node pack by Fannovel16, with its RIFE VFI, FILM VFI and eleven more VFI nodes. It downloads its own model files on first use and keeps them inside its own folder, not in models/.

Whichever you use, the frame rate is the part people get wrong:

• Interpolating a clip with a multiplier of 2 turns N frames into (N − 1) × 2 + 1, not 2N.
• To keep the clip the same length, multiply the output frame rate by the same number. A Wan 2.2 14B clip is 81 frames at 16 fps; after ×2 it is 161 frames, and it belongs at 32 fps.
• Leave the save node at 16 fps and the same 161 frames play for about 10 seconds instead of 5. That is slow motion, not smoother motion.

We read ComfyUI's source, the node pack's source and issue tracker, and the Hugging Face API on 2026-10-10. We have not timed or measured any interpolation run ourselves, so this page has no speed or VRAM figures of ours.

The built-in nodes

Added by kijai in ComfyUI pull request #13258, merged 2026-04-22. The pull request describes it as PyTorch-only support for RIFE (MIT) and FILM (Apache 2.0).

There is nothing else to set. The loader detects from the file's contents whether it is FILM or RIFE, and runs it in fp16 when ComfyUI decides the GPU supports it, fp32 otherwise. If the GPU runs out of memory mid-clip, the node halves the number of in-between frames it computes at once and tries again, down to one.

The model files

From Comfy-Org/frame_interpolation, folder frame_interpolation/. Sizes are decimal megabytes from the Hugging Face API.

ComfyUI/
└── models/
    └── frame_interpolation/
        ├── film_net_fp16.safetensors
        └── rife_v4.25.safetensors

The bundled template loads film_net_fp16.safetensors. If you want RIFE, pick a RIFE file in the loader; nothing else in the graph changes. RIFE's own Practical-RIFE README recommends 4.25 by default for most scenes.

The loader only accepts RIFE files with five flow blocks, the layout RIFE moved to with 4.25. Older RIFE checkpoints such as rife49.pth from the node pack below are rejected with Unrecognized frame interpolation model format.

What the template does with the frame rate

The template's subgraph has an integer Multiplier and a switch labelled Apply multiplier to FPS?, on by default. When it is on, a math node multiplies the source video's frame rate by the multiplier before the video is saved, so the clip keeps its length. Turn it off and you get slow motion instead.

The Fannovel16 node pack

Fannovel16/ComfyUI-Frame-Interpolation, version 1.0.11 in its pyproject.toml, MIT licence. Its nodes sit in the category ComfyUI-Frame-Interpolation/VFI:

The "Needs CuPy" column comes from the code: only the GMFSS Fortuna, M2M, MoMo, Sepconv and STMFNet model code imports the CuPy kernels. RIFE VFI and FILM VFI run without it. The pack also ships a few helper nodes, such as Make Interpolation State List, which marks frames to skip.

The RIFE VFI node is displayed as "RIFE VFI (recommend rife4.25+)", but no 4.25 file is in its list. The nearest is rife426.pth.

Install

Install it through ComfyUI Manager, or clone it into custom_nodes/ and run its installer from the Python that runs ComfyUI:

cd ComfyUI/custom_nodes/ComfyUI-Frame-Interpolation
python install.py

On the Windows portable build, the README says to run install.bat, which calls install.py with the portable python_embeded interpreter. install.py installs the plain requirements, then tries to install CuPy matched to the CUDA version it finds in your PyTorch install.

Where its models come from and where they go

The pack downloads each file the first time a node uses it, into its own folder: ckpts/<model>/ inside the node pack, for example ckpts/rife/rife49.pth. ComfyUI/models/ is not used; an open issue asks for that.

It tries these sources in order, from vfi_utils.py:

1. styler00dollar/VSGAN-tensorrt-docker releases, tag models
2. Fannovel16/ComfyUI-Frame-Interpolation releases, tag models
3. dajes/frame-interpolation-pytorch releases, tag v1.0.0
4. For rife47.pth, rife49.pth and the sudo_rife4 file only: a list of third-party Hugging Face mirrors

The first source no longer carries any RIFE file, so a first run prints Failed! Trying another endpoint. before it succeeds. That line is normal. The sizes on the sources that do have them:

The RIFE VFI settings

From the node's code, with its defaults:

FILM VFI has only ckpt_name, clear_cache_after_n_frames and multiplier.

The frame rate math

Interpolation adds frames between each pair of frames you already have. With N input frames there are N − 1 gaps, and a multiplier of m puts m − 1 new frames in each gap. Both the built-in node and the node pack's RIFE and FILM nodes return:

output frames = (N − 1) × m + 1

The clip only keeps its length if the frame rate goes up by the same m. Using the defaults of ComfyUI's own templates:

The built-in template does this multiplication for you. With the node pack and VideoHelperSuite's Video Combine, you set frame_rate yourself: source fps times the multiplier. The node pack takes whole-number multipliers only, so 16 fps becomes 32 or 48, never exactly 24 or 30.

Interpolation does not fix the lightx2v slow-motion problem. That one is about how far things move in the frames the model generated, and doubling the frames keeps that motion; it only makes it smoother. Our Wan 2.2 lightx2v LoRA page covers what lightx2v has said about it.

GIMM-VFI, the third option

Kijai's ComfyUI-GIMM-VFI wraps GIMM-VFI, a different interpolation model, and ComfyUI's template list has a "Frame Interpolation: GIMM-VFI" workflow that uses it with VideoHelperSuite. Before you choose it, two things from its repository:

• It needs CuPy. Its requirements list cupy-cuda12x>=13.3.0.
• Its licence is non-commercial. The repository and the model files carry the S-Lab License 1.0, which permits redistribution and use for non-commercial purposes only.

Its node downloads the weights from Kijai/GIMM-VFI_safetensors into ComfyUI/models/interpolation/gimm-vfi/. The two GIMM files are 79,204,556 bytes (gimmvfi_r_arb_lpips_fp32.safetensors, 79.2 MB) and 122,632,368 bytes (gimmvfi_f_arb_lpips_fp32.safetensors, 122.6 MB), plus a flow model for each.

Common errors

If the run stops with an out-of-memory error before interpolation even starts, the problem is the video model, not the interpolator. Our ComfyUI out-of-memory page and troubleshooting page cover that.

Where the advice online disagrees

• "You need the Fannovel16 pack." True until April 2026. Many tutorials predate the built-in nodes.
• ComfyUI's tutorial page says the workflow contains custom nodes. The built-in template, utility_video_frame_interpolation.json, uses only core nodes. The older "Frame Interpolation: FILM" template does need the Fannovel16 pack and VideoHelperSuite, and both templates link to the same tutorial page.
• The template's note lists film_net_fp16.safetensors at 65.7 MB. Hugging Face shows 68.9 MB. Both are right: the note counts in binary megabytes (MiB).
• "Use RIFE 4.9." It is still the node pack's default. RIFE's own README recommends 4.25, which only the built-in route offers as a ready file.

What nobody has published

• A speed or VRAM comparison between RIFE and FILM inside ComfyUI, on a named consumer GPU, with versions stated. RIFE's ECCV README claims more than 30 fps for 2× 720p on a 2080 Ti, with its own script, not ComfyUI.
• A side-by-side quality test of RIFE 4.25, 4.26 and FILM on Wan or LTX output.

Interpolation is not part of the system requirements checker, whose only preset is MiniMax H3. The MiniMax H3 templates on our workflows page already save at 24 fps.

Licence and downloads

• The Fannovel16 node pack is MIT. Its model files come from the sources listed above, each under its own project's terms.
• RIFE: Practical-RIFE is MIT, and its README says the model links are under the same licence. FILM: Google Research's frame-interpolation repository and the dajes PyTorch port are both Apache 2.0.
• Comfy-Org/frame_interpolation is tagged "mit-and-apache-2.0".
• GIMM-VFI: S-Lab License 1.0, non-commercial use only.

We do not host any of these files. Download them from the repositories named below.

GenVidKit is an independent guide. It is not affiliated with Comfy Org, Fannovel16, the RIFE authors, Google, Kijai, the GIMM-VFI authors or Hugging Face.

Sources

All read on 2026-10-10.

• ComfyUI comfy_extras/nodes_frame_interpolation.py and folder_paths.py — the built-in nodes, their inputs, the model folder and the RIFE file check.
• ComfyUI pull request #13258 and ComfyUI releases — when the nodes were added and the first release with them.
• Comfy-Org/frame_interpolation — files, byte counts, folder and licence tag.
• Comfy-Org/workflow_templates — the three frame interpolation templates, and the Wan 2.2 templates' frame counts and fps.
• ComfyUI frame interpolation tutorial and FrameInterpolate node reference — the custom-nodes notice and the output frame formula.
• Fannovel16/ComfyUI-Frame-Interpolation — README, install.py, install.bat, vfi_utils.py, each node's code, the licence, and the models release file sizes.
• Issues #142, #138, #141, #134, #120, #111, #106, #93, #89 and #130, and pull requests #136 and #131 — the errors and their status.
• dajes/frame-interpolation-pytorch and styler00dollar/VSGAN-tensorrt-docker release assets — which download sources still carry which file.
• hzwer/Practical-RIFE and hzwer/ECCV2022-RIFE — the 4.25 recommendation, scale advice, licence and the 2080 Ti claim.
• google-research/frame-interpolation — FILM's licence.
• kijai/ComfyUI-GIMM-VFI and Kijai/GIMM-VFI_safetensors — CuPy requirement, licence, download folder and file sizes.