How we tested
Wan 2.2 renders at 16 fps, and at 16 fps fast motion stutters. The lab's own notes say to run RIFE 2x on every Wan clip, but until today nobody here had timed it properly, and FILM, the other interpolator in Comfy's core nodes, had never run on this Spark at all. So we ran both, fresh, on Nov 6 2026.
The clips. Three Wan 2.2 I2V A14B clips from the lab's Nov 1 run, all 1280x704, 81 frames, 16 fps, 5.06 s, silent:
- Skateboard (fast board and leg motion; the prompt asks for a kickflip, and Wan didn't render one),
- Dog shaking off water (fast flapping ears, flying droplets: the hard case),
- Cartoon fox waving (slow, mostly still; numbers only, not on this page).
Test 1, the real job: each model doubles each clip from 16 to 32 fps (161 frames). That's the six 32 fps clips in the comparisons above.
Test 2, against the truth. Interpolated frames have no right answer to compare with, so we made one. We threw away every other frame of each clip (16 fps down to 8 fps), had each method rebuild 16 fps, and scored the frames it invented against the real frames it never saw: PSNR on the brightness channel, and SSIM (8x8 windows). Higher is better for both. Rebuilding 8 to 16 fps is harder than the real 16 to 32 job, because things move twice as far between frames, so treat these as a stress test. We scored three free baselines the same way: repeating the previous frame, a 50/50 blend of the two neighbours, and ffmpeg's minterpolate motion-compensated interpolation on the CPU.
Then we looked: the worst-scoring frame in each clip, side by side for every method, and frames 99-110 of both 32 fps skateboard clips.
Results against the real frames
Average over the 40 invented frames per clip (39 for ffmpeg, which output two fewer frames). PSNR in dB / SSIM.
| Clip | Repeat frame | Blend | ffmpeg minterpolate | RIFE v4.26 | FILM |
|---|---|---|---|---|---|
| Skateboard | 23.21 / 0.834 | 25.46 / 0.857 | 27.09 / 0.892 | 27.86 / 0.889 | 27.72 / 0.892 |
| Dog | 25.43 / 0.867 | 27.92 / 0.895 | 30.49 / 0.929 | 30.66 / 0.930 | 31.21 / 0.934 |
| Fox | 29.86 / 0.960 | 32.16 / 0.969 | 33.45 / 0.977 | 33.44 / 0.975 | 33.41 / 0.975 |
What the table says: RIFE and FILM are a tie. They're within 0.6 dB of each other on every clip, and neither wins all three. Both clearly beat repeating or blending frames.
What the table hides: ffmpeg's minterpolate scores almost the same, and it looks far worse. On skateboard frame 53 it breaks the board into a trail of blocks, and on dog frame 49 it tears the ear and doubles the tail (both are in the reference images under the first clip). PSNR averages the whole frame, and most of the frame is concrete or lake that every method gets right. Don't pick an interpolator from a PSNR number alone. Look at the fast parts.
The worst frames tell the rest of the story:
- Skateboard, frame 53: RIFE's board is clean and sits closest to where the real one is. FILM's is clean too, with a faint second edge on the deck and wheels.
- Dog, frame 49: the ear is mid-flap. RIFE turns it into a smear and FILM keeps a bit more of its shape. Neither one has the water droplets near the dog's face that the real frame has. When something moves this far between frames, interpolation just averages it away.
At the real job (16 to 32 fps), things move half as far between frames, and both models did fine: smooth in-between frames on the skateboard with no tearing (frames 99-110), and the dog's ear keeps its shape through the flaps (frames 94-101). At full speed we can't tell RIFE's 32 fps clips from FILM's.
Setup and gotchas
- Nothing to install.
FrameInterpolationModelLoaderandFrameInterpolateare ComfyUI 0.43 core nodes. The models are Comfy-Org's repackage (rife_v4.26.safetensors, fp32, 23 MB, andfilm_net_fp16.safetensors, 69 MB) in theframe_interpolationmodel folder. Both ran on the GB10 first time. - Set the output frame rate yourself.
FrameInterpolatehands back frames, not a frame rate.CreateVideoneeds 2x the source rate (32 for a 16 fps Wan clip). The lab's graph builder (vlab.py, kindinterp) defaults to 50, which would play a 2x clip about 1.6x too fast. We passed 32. - 2x gives 2N-1 frames. 81 frames in, 161 out, so the 32 fps clip runs 5.03 s against the source's 5.06 s. It doesn't pad the last frame. Keep that in mind if you're cutting to audio.
- It passes audio through. The graph wires the source's audio into
CreateVideo, so a clip with sound (an S2V or LTX shot) keeps it. - Which server. The lab's main ComfyUI (:8191) only picks up the
frame_interpolationfolder after a restart. We ran on the lab's second server (:8192), which has it.
Settings
| Setting | Value |
|---|---|
| Models | rife_v4.26.safetensors / film_net_fp16.safetensors |
| Multiplier | 2 |
| Output | CreateVideo fps 32 (test 1) or 16 (test 2), SaveVideo mp4 h264 |
| Input | Wan 2.2 I2V A14B fp8 + lightx2v 4-step LoRA, 1280x704, 81 frames, 16 fps, seed 42 |
| Ground-truth input | even frames only, 41 frames at 8 fps, re-encoded with x264 CRF 10 |
| ffmpeg baseline | minterpolate=fps=16:mi_mode=mci:mc_mode=aobmc:vsbmc=1 |
Speed and memory
Times are ComfyUI's own "Prompt executed" figures: load the video, interpolate, encode, save. The first RIFE job includes loading the model.
| Skateboard | Dog | Fox | s of compute per s of video | |
|---|---|---|---|---|
| RIFE v4.26, 16 to 32 fps | 6.71 s | 5.38 s | 5.20 s | about 1.1 |
| FILM, 16 to 32 fps | 28.93 s | 30.16 s | 29.27 s | about 5.9 |
| RIFE, 8 to 16 fps | 3.40 s | 3.16 s | 3.41 s | |
| FILM, 8 to 16 fps | 15.65 s | 15.12 s | 14.37 s | |
| ffmpeg minterpolate, 8 to 16 fps (CPU, 20 cores) | 5.0 s | 4.7 s | 4.0 s |
The 16 to 32 fps outputs are 5.03 s long. FILM is about 5x slower than RIFE, and in our test that bought nothing.
Memory, sampled once a second with nvidia-smi for the ComfyUI process: RIFE peaked at 0.8 GB (771 MiB) and FILM at 4.0 GB (4,099 MiB). On the Spark's unified memory that's the process's GPU allocation, not a system total. Across the whole system, available memory dipped about 1 GB during the RIFE jobs and up to about 12 GB during FILM. Either one fits next to the bigger models without trouble.
The whole 12-job test held the GPU for 183 s.
What we'd test next
- RIFE at 3x or 4x (16 to 48 or 64 fps), and the
rife_v4.26_heavycheckpoint Comfy-Org also ships. - Interpolating 8 fps renders on purpose: render half the frames with Wan, then let RIFE fill in. The dog clip says fast motion will smear.