MOMO VFI (only supports 2x multiplier)

MoMo is the unusual one: a diffusion-based frame interpolator. Where every other model in the ComfyUI Frame Interpolation pack does a single forward pass, MoMo actually runs a small denoising loop to generate the in-between frame - which is why it has a num_inference_steps control that looks like it wandered in from a KSampler. It's slower than the flow-based nodes, and it only does 2x, but the diffusion approach can give it an edge on ambiguous or complex motion.

Frame interpolation, quickly: it invents new frames between your existing ones so a choppy low-fps clip plays smooth. You generate video cheaply at a low frame count with AnimateDiff or Wan, then interpolate up to a watchable frame rate instead of paying to diffuse every real frame. MoMo does that step - with a mini-diffusion process of its own.

How it works

MoMo comes from a 2024 paper, "Disentangled Motion Modeling for Video Frame Interpolation." The trick is that it separates motion modeling from appearance: it uses a diffusion model to generate the intermediate optical flow (the motion), then warps and synthesizes the actual pixels from that. Disentangling the two means the diffusion process only has to reason about how things move, not repaint the whole image, which keeps it tractable. Because there's a denoising loop involved, you get a steps control - more steps, more refinement, more time.

The inputs that matter

• frames (IMAGE) - your clip, at least 2 frames, from a VAE decode or a Load Images node.
• ckpt_name - two weights: momo-base.pth (fuller quality) and momo-lite.pth (lighter and faster). Both download on first run. Start with base unless you're tight on time or memory.
• multiplier (INT, default 2) - locked at 2. MoMo is 2x-only, as its display name says. For a bigger jump, run a second pass or use a higher-multiplier model.
• num_inference_steps (INT, default 8, range 2–20) - the diffusion steps. This is the quality-vs-speed dial unique to MoMo: fewer steps are faster and rougher, more steps are slower and cleaner. The default of 8 is a reasonable middle; push toward 12–16 if you want more polish and have the patience, drop to 4 for quick previews.
• clear_cache_after_n_frames (INT, default 10) - the OOM valve; lower it on long clips if memory gets tight.

An optional optional_interpolation_states input takes a Make Interpolation State List for skipping specific frame pairs. Usually left unwired.

Output is a single IMAGE batch - send it to a Video Combine node (VideoHelperSuite) to encode.

Installing it

It ships in the whole ComfyUI Frame Interpolation pack:

• ComfyUI Manager - search ComfyUI Frame Interpolation, install, restart.
• Manual - cd ComfyUI/custom_nodes && git clone https://github.com/Fannovel16/ComfyUI-Frame-Interpolation, then python install.py (Linux, in your ComfyUI venv) or install.bat (Windows). Restart.

The MoMo checkpoints download on first use. It's a newer addition, so update the pack (git pull or via ComfyUI Manager) if the node doesn't show up.

Common issues

The thing to internalize is that MoMo is slower by design - it's running a diffusion loop per interpolated frame. If it feels sluggish, that's expected; lower num_inference_steps, switch to momo-lite, and remember you're comparing a generative method against single-pass flow models. If you don't need the quality, a flow-based node like FILM or IFRNet will be far faster.

The pack-wide install issues apply too: cupy is the dependency that breaks setups, so run install.bat on Windows rather than install.py, and if the GPU is idle while interpolation grinds, the backend fell back to CPU - verify cupy against your CUDA version. On long clips, drop clear_cache_after_n_frames before you OOM.