RIFE vs FILM on the Spark: both turn 16 fps Wan clips into clean 32 fps, and RIFE does it 5x faster

Rated G

Two frame interpolators on three Wan 2.2 clips, timed, and scored against real frames they never saw. The free ffmpeg alternative is the one that tears.

The walkthrough (175 s): AI hosts Daisy Lane and Rafael Duarte (AI voices, ElevenLabs) show the skateboard at 16 fps next to RIFE and FILM at 32, how we scored both against real frames, why ffmpeg's free interpolation scores close and still breaks the board, where both models smear, and the settings that ran. Lip-sync is loose at pauses, so the edit cuts to the clips over the long ones.
Prompt and settings

Settings: Four host segments (47.3 s of speech, eleven_v4) made with LTX 2.5 image+audio-to-video from each host's on-set still, seed 42; seven voice-over panels and cut-aways in Remotion using this post's own clips; 1920x1080, 30 fps

Reference images (2)
The ground-truth test, at half speed. We dropped every other frame of the 16 fps skateboard clip, had each method rebuild it, and lined the result up with the real frames. Top left: real. Top right: ffmpeg minterpolate on the CPU. Bottom: RIFE (left) and FILM (right). Watch ffmpeg's board break into blocks around 6-7 s.
Prompt and settings

Prompt: A skateboarder in a grey hoodie rides toward the camera on a concrete plaza and pops a kickflip, the board spinning under his feet before he lands and rolls past. Tracking camera, bright overcast daylight, photorealistic, sharp.

Settings: Input: the clip's even frames only (41 frames, 8 fps, CRF 10). Each method rebuilt 16 fps. RIFE / FILM: multiplier 2, CreateVideo fps 16. ffmpeg: minterpolate=fps=16:mi_mode=mci:mc_mode=aobmc:vsbmc=1. Grid played at 8 fps (half speed). Source: Wan 2.2 I2V A14B fp8 + lightx2v 4-step LoRA, 1280x704, 81 frames, 16 fps, 4 steps, euler, cfg 1, seed 42 (lab run, Nov 1). Silent.

Reference images (4)

Skateboard: Wan 16 fps vs RIFE 32 fps vs FILM 32 fps

  • Clip 3: Skateboard source: Wan 2.2 at its native 16 fps. The stutter is what interpolation is for.
    Prompt and settings

    Prompt: A skateboarder in a grey hoodie rides toward the camera on a concrete plaza and pops a kickflip, the board spinning under his feet before he lands and rolls past. Tracking camera, bright overcast daylight, photorealistic, sharp.

    Settings: Source: Wan 2.2 I2V A14B fp8 + lightx2v 4-step LoRA, 1280x704, 81 frames, 16 fps, 4 steps, euler, cfg 1, seed 42 (lab run, Nov 1). Silent.

  • Clip 4: Skateboard, RIFE v4.26 2x to 32 fps. 6.71 s of compute, model load included (the first job).
    Prompt and settings

    Prompt: A skateboarder in a grey hoodie rides toward the camera on a concrete plaza and pops a kickflip, the board spinning under his feet before he lands and rolls past. Tracking camera, bright overcast daylight, photorealistic, sharp.

    Settings: rife_v4.26.safetensors, multiplier 2, CreateVideo fps 32: 81 frames in, 161 out (5.03 s). ComfyUI 0.43.0 core nodes on :8192. ComfyUI 'Prompt executed' 6.71 s (first job, includes model load).

  • Clip 5: Skateboard, FILM 2x to 32 fps. 28.93 s of compute.
    Prompt and settings

    Prompt: A skateboarder in a grey hoodie rides toward the camera on a concrete plaza and pops a kickflip, the board spinning under his feet before he lands and rolls past. Tracking camera, bright overcast daylight, photorealistic, sharp.

    Settings: film_net_fp16.safetensors, multiplier 2, CreateVideo fps 32: 81 frames in, 161 out (5.03 s). ComfyUI 0.43.0 core nodes on :8192. ComfyUI 'Prompt executed' 28.93 s.

Dog shaking off water: Wan 16 fps vs RIFE 32 fps vs FILM 32 fps

  • Clip 6: Dog source: Wan 2.2 at 16 fps. Fast ear flaps and spray, the hard case.
    Prompt and settings

    Prompt: A wet golden retriever standing on a lake dock shakes the water off its coat, droplets flying in every direction, ears flapping, in bright afternoon sun. Static camera at the dog's eye level, photorealistic, slow motion feel.

    Settings: Source: Wan 2.2 I2V A14B fp8 + lightx2v 4-step LoRA, 1280x704, 81 frames, 16 fps, 4 steps, euler, cfg 1, seed 42 (lab run, Nov 1). Silent.

  • Clip 7: Dog, RIFE v4.26 2x to 32 fps. Smoother than the source; at this rate the ear keeps its shape through the flaps. 5.38 s of compute.
    Prompt and settings

    Prompt: A wet golden retriever standing on a lake dock shakes the water off its coat, droplets flying in every direction, ears flapping, in bright afternoon sun. Static camera at the dog's eye level, photorealistic, slow motion feel.

    Settings: rife_v4.26.safetensors, multiplier 2, CreateVideo fps 32: 81 frames in, 161 out (5.03 s). ComfyUI 0.43.0 core nodes on :8192. ComfyUI 'Prompt executed' 5.38 s.

  • Clip 8: Dog, FILM 2x to 32 fps. Hard to tell from RIFE at full speed. 30.16 s of compute.
    Prompt and settings

    Prompt: A wet golden retriever standing on a lake dock shakes the water off its coat, droplets flying in every direction, ears flapping, in bright afternoon sun. Static camera at the dog's eye level, photorealistic, slow motion feel.

    Settings: film_net_fp16.safetensors, multiplier 2, CreateVideo fps 32: 81 frames in, 161 out (5.03 s). ComfyUI 0.43.0 core nodes on :8192. ComfyUI 'Prompt executed' 30.16 s.

Verdict

Use RIFE v4.26 on every 16 fps Wan clip: it doubles a 5-second 1280x704 shot to 32 fps in about 5 seconds of compute and under 1 GB of GPU memory. FILM made the same quality in our test (within 0.6 dB either way on real held-out frames) for about 5x the time, so it isn't worth it here. Neither one can invent what moves too far between frames: when we made the gap twice as big (8 to 16 fps), the dog's flapping ear smeared and its water droplets vanished in both. Don't swap in ffmpeg's free motion interpolation to save five seconds of GPU: its numbers look close, but it shreds the skateboard into blocks.

Credits and settings

ModelRIFE v4.26 vs FILM (frame interpolation)
MakerRIFE: hzwer (Practical-RIFE). FILM: Google Research. Both repackaged for ComfyUI by Comfy-Org.
Versionrife_v4.26 (fp32, 22.7 MB) and film_net_fp16 (68.9 MB), Comfy-Org/Frame-Interpolation repackage; ComfyUI 0.43.0 core nodes
What it doesframe interpolation
LicenseRIFE: MIT. FILM: Apache-2.0.
HardwareDGX Spark: NVIDIA GB10, ARM (aarch64), 128 GB unified memory. ComfyUI 0.43.0, PyTorch 2.11.0+cu130, core frame-interpolation nodes.
Speed1.1 s of compute per second of video. RIFE v4.26, 2x, 1280x704, 81 frames in, 161 out (5.03 s of video): 5.2-6.7 s per clip (ComfyUI 'Prompt executed', first run includes model load). FILM on the same clips: 28.9-30.2 s, about 5.9 s per second of video.
Peak memory4 GB. nvidia-smi per-process use of the ComfyUI server, sampled every second: RIFE 0.8 GB (771 MiB), FILM 4.0 GB (4,099 MiB). That isn't a system total on unified memory; system MemAvailable dipped about 1 GB during RIFE and up to about 12 GB during FILM.
Tested onNov 6, 2026
ReleasedSep 21, 2024
AI hosts

Daisy Lane (AI host; AI voice)

Rafael Duarte (AI host; AI voice)

Narration
Not supplied
Music source
Not supplied

What it does well

  • Fast: RIFE took 5.2-6.7 s per 5 s clip at 1280x704 (about 1.1 s of compute per second of video), FILM 28.9-30.2 s (about 5.9)
  • Small: RIFE peaked at 0.8 GB on the GPU (nvidia-smi, the ComfyUI process), FILM at 4.0 GB; model files are 23 MB and 69 MB
  • Clean in-betweens on fast board and leg motion: frames 99-110 of both 32 fps skateboard clips show the board moving smoothly with no tearing
  • On real held-out frames both beat a plain blend by 1.3-3.3 dB and frame repeat by 3.5-5.8 dB (PSNR) on all three clips
  • ComfyUI 0.43 core nodes, no custom nodes, nothing to fix on aarch64 / GB10

Where it breaks

  • Fast, thin things smear when the gap between frames is big: in the 8 to 16 fps test the dog's flapping ear turns into a soft blob and the flying droplets vanish in both RIFE and FILM (dog grid, frame 49). At 16 to 32 fps the ear held
  • FILM leaves a faint second edge on the skateboard deck and wheels where RIFE's board is clean (skateboard grid, frame 53)
  • Interpolation can't add motion the source never had: the Wan clip's board never flips, and neither model makes it flip
  • The lab's graph builder defaults to 50 fps output; leave it and a 2x clip plays about 1.6x too fast. Set the output fps to 2x the source by hand

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.

ClipRepeat frameBlendffmpeg minterpolateRIFE v4.26FILM
Skateboard23.21 / 0.83425.46 / 0.85727.09 / 0.89227.86 / 0.88927.72 / 0.892
Dog25.43 / 0.86727.92 / 0.89530.49 / 0.92930.66 / 0.93031.21 / 0.934
Fox29.86 / 0.96032.16 / 0.96933.45 / 0.97733.44 / 0.97533.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. FrameInterpolationModelLoader and FrameInterpolate are ComfyUI 0.43 core nodes. The models are Comfy-Org's repackage (rife_v4.26.safetensors, fp32, 23 MB, and film_net_fp16.safetensors, 69 MB) in the frame_interpolation model folder. Both ran on the GB10 first time.
  • Set the output frame rate yourself. FrameInterpolate hands back frames, not a frame rate. CreateVideo needs 2x the source rate (32 for a 16 fps Wan clip). The lab's graph builder (vlab.py, kind interp) 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_interpolation folder after a restart. We ran on the lab's second server (:8192), which has it.

Settings

SettingValue
Modelsrife_v4.26.safetensors / film_net_fp16.safetensors
Multiplier2
OutputCreateVideo fps 32 (test 1) or 16 (test 2), SaveVideo mp4 h264
InputWan 2.2 I2V A14B fp8 + lightx2v 4-step LoRA, 1280x704, 81 frames, 16 fps, seed 42
Ground-truth inputeven frames only, 41 frames at 8 fps, re-encoded with x264 CRF 10
ffmpeg baselineminterpolate=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.

SkateboardDogFoxs of compute per s of video
RIFE v4.26, 16 to 32 fps6.71 s5.38 s5.20 sabout 1.1
FILM, 16 to 32 fps28.93 s30.16 s29.27 sabout 5.9
RIFE, 8 to 16 fps3.40 s3.16 s3.41 s
FILM, 8 to 16 fps15.65 s15.12 s14.37 s
ffmpeg minterpolate, 8 to 16 fps (CPU, 20 cores)5.0 s4.7 s4.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_heavy checkpoint 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.

ComfyUI workflow for the 2x interpolation (API format; swap model_name to film_net_fp16.safetensors for FILM) ↗