FILM VFI

You generated a video clip and it looks choppy. Sixteen frames of AnimateDiff, or a short Wan render, and the motion stutters because there just aren't enough frames per second. FILM VFI is the node that fixes that: it invents brand-new frames between the ones you already have, so a stuttery clip turns into a smooth one without re-running the expensive diffusion model. This is frame interpolation, and FILM is the one I'd reach for first when the motion between frames is large.

FILM stands for "Frame Interpolation for Large Motion" - a Google Research model from ECCV 2022, and the name is the whole pitch. Most interpolators do fine when the object barely moves between frames and fall apart when something flies across the screen, leaving you with ghosting and torn edges. FILM was trained specifically to handle the big jumps. If your source clip is low-fps with real displacement between frames - a fast pan, a hand swinging through - this is the model that holds together.

Where it fits in a workflow

Interpolation is a post-processing step. It lives at the tail end of a video pipeline, after your KSampler and VAE decode have produced a batch of frames but before you encode to a file. The classic use is squeezing more life out of a slow generator: models like AnimateDiff or Wan are expensive per frame, so people generate at a low frame count and then interpolate 2x or 4x to hit a watchable frame rate. It's far cheaper to invent an in-between frame than to diffuse a real one.

The other reason FILM comes up: it's the fallback that works when RIFE (the pack's flagship node) doesn't. RIFE leans on a CUDA-only backend, and Mac users routinely get pointed at FILM instead - it runs through plainer PyTorch and just works in more places.

How it works

FILM predicts optical flow - where each pixel travels from one frame to the next - then warps and blends the two source frames along that flow to synthesize the middle. Its trick for large motion is a shared multi-scale feature pyramid, so it can reason about motion that's tiny in one region and huge in another at the same time. You don't touch any of that; you just feed it frames.

The inputs that matter

• frames (IMAGE) - the batch of frames you want to interpolate, at least 2. This is the whole clip, wired straight from your VAE decode or a Load Images node.
• multiplier (INT, default 2) - how many frames come out per input gap. 2 doubles your frame count, 4 quadruples it. Start at 2; only push higher if you actually need the extra smoothness, because output frames scale with it.
• clear_cache_after_n_frames (INT, default 10) - the OOM safety valve. If you're hitting out-of-memory on a long clip, lower it; the node frees VRAM more often at the cost of some speed. Raise it on short clips for a bit more throughput.
• ckpt_name - the model weights. There's one option, film_net_fp32.pt, which downloads automatically on first run.

There's also an optional optional_interpolation_states input that takes the output of a Make Interpolation State List node, for skipping specific frame pairs (scene cuts, say). Most of the time you leave it unwired.

The single output is IMAGE - the expanded frame batch. Send it into a Video Combine node from VideoHelperSuite (or a plain Save Image sequence) to turn it back into a file.

Installing it

It ships in the ComfyUI Frame Interpolation pack, so you install the whole set, not just this node.

• ComfyUI Manager - search ComfyUI Frame Interpolation, install, restart.
• Manual - cd ComfyUI/custom_nodes && git clone https://github.com/Fannovel16/ComfyUI-Frame-Interpolation, then run the installer from inside your ComfyUI venv: python install.py on Linux, or install.bat on Windows. Restart Comfy afterward.

The film_net_fp32.pt checkpoint downloads on first use, so the first run is slower while it fetches.

Common issues

The pack's headline dependency is cupy, a CUDA library that's a pain to install cleanly. On Windows, run install.bat - not install.py or install-cupy.py - or cupy won't set up right. FILM itself is more forgiving than RIFE here, which is exactly why people fall back to it when RIFE throws device errors, but a broken pack install still takes everything down.

No NVIDIA card? The pack has an experimental taichi backend: pip install taichi and set ops_backend: taichi in config.yaml. If you get a NotImplementedError, that node isn't taichi-compatible, but FILM is a safe bet on that path.

If you see the GPU sitting idle while interpolation crawls, that's usually the backend having fallen back to CPU - a real, recurring complaint with this pack. Confirm cupy actually installed against your CUDA version before blaming the node. And if you OOM on a big clip, drop clear_cache_after_n_frames first.