What is frame interpolation?
Frame interpolation invents frames that were never shot: a model looks at two real frames, works out how everything moved between them, and builds the picture in between. One new frame in every gap takes 30fps to 60. It adds smoothness, never detail. In Crisp it runs after the upscale, on the already-upscaled frames, using rife-v4.6 through rife-ncnn-vulkan, and the original audio is stream-copied so nothing drifts.
Frame interpolation creates frames that were never captured. Given two consecutive frames, the model works out how things moved between them and generates one or more intermediate pictures. Do that once between every pair and 30fps footage becomes 60fps. Do it more aggressively and you can push further, or turn ordinary footage into slow motion that was never shot as slow motion.
It's motion estimation, not guesswork
The useful mental model is that the software is tracking, not painting. It builds a map of how each region of the picture moved from one frame to the next, then warps both frames towards a point in between and blends them. Modern approaches estimate that motion field with a neural network, which is what makes them dramatically better than the frame blending that older editors offered.
Frame blending simply cross-fades two frames. It produces a soft double image on anything that moves. Real interpolation moves the pixels, so a hand crossing the frame stays a hand rather than becoming two transparent hands.
Where it goes wrong
Interpolation fails in specific, predictable places, and knowing them saves a lot of wasted rendering.
It struggles when something appears or disappears between frames, because there's nothing to track towards. Edges of the frame suffer for the same reason. It struggles with fast motion where an object travels a long way between samples, since the search has to guess which part of frame two corresponds to which part of frame one. Repeating patterns like railings, brickwork and venetian blinds confuse the matching badly. Motion blur is another one: a heavily blurred subject has no crisp features to track, so the estimate wanders.
The failure looks like warping, tearing at edges, or a brief rubbery wobble as something passes in front of something else. It's usually confined to a handful of frames, which is precisely why it slips past a quick scrub through the timeline.
When smoother is worse
There's a reason cinema still shoots at 24fps. That frame rate carries strong associations, and interpolating a film-look sequence to 60fps produces the effect people describe as looking like a soap opera, or like behind-the-scenes video rather than the film itself. It isn't a technical fault. The motion is genuinely smoother. It just reads as cheaper.
So the honest rule is that interpolation belongs on footage where smoothness is a virtue. Gameplay capture, sports, action cameras, drone shots, screen recordings and anything you intend to slow down all benefit. Narrative and cinematic work usually shouldn't be touched.
Doing it on a Mac
Crisp runs interpolation on-device. You can either pick a multiplier from the Smooth motion control or type what you want, and it keeps the audio in sync rather than leaving you to fix drift afterwards. Because it runs locally there's no per-minute billing, which matters here more than usual: interpolation is one of the most compute-heavy things you can ask of a clip, and it's exactly the operation cloud services price aggressively.
The work is done by rife-ncnn-vulkan, running the rife-v4.6 model. That is a Vulkan compute program executed on the Mac's GPU through Metal. There is one model, not a menu of them: the older rife-anime (v1.8) refuses a custom frame count outright — it answers "only rife-v4 model support custom numframe and timestep" and produces nothing — so every job goes through v4.6.
Only one GPU process runs at a time. The interpolator takes the same engine-wide lock the upscaler takes, because both are ncnn/Vulkan programs allocating Metal memory, and two of them running at once is how a render used to die mid-job.
Where it runs in the chain: after the upscale, not before
This is the detail that decides what a smooth-motion job costs, and it is worth being exact about. Crisp works a clip in segments. For each segment it decodes the frames, runs the upscaling model over them, and only then hands the upscaled frames to the interpolator. The encoder reads the interpolated directory.
So the motion model is not estimating over your source frames. It is estimating over frames at output resolution. A 2× upscale followed by 2× smooth motion means the interpolator is working on pictures with four times the pixels of the source, and producing twice as many of them. That is the expensive order, and it is not a setting — there is no control that runs interpolation first.
The clearest evidence of the cost is Crisp's own refusal. Before a job starts, it checks whether the working disk can hold a segment, and when smooth motion is on it budgets output-resolution frames at one plus the multiplier — a 2× smooth-motion job reserves room for three full sets of output-sized PNGs per segment, on top of the raw decoded set. If the disk can't take it, Crisp says so up front instead of spending the GPU time and failing at the write. The same arithmetic is why smooth motion makes an already slow job much slower; see why 4K exports take so long.
Two smaller behaviours fall out of the same place in the pipeline. A segment with fewer than two frames is encoded untouched, because a single frame has no pair to interpolate between. And the output frame rate for each segment is derived from the number of frames the model actually emitted, not the number requested — if fewer come back, the rate is scaled to match, so the picture keeps its real duration and the stream-copied audio is never truncated to fit.
What the multiplier can be
The Smooth motion control offers three choices: Off, 2× fps (the 30→60 case), and 3× fps. The API and the command line accept 1, 2, 3 or 4, and reject anything else with a plain message rather than quietly rounding — ask for 1.5 and you are told the value must be 1, 2, 3 or 4, instead of silently getting a different multiplier than you asked for.
Typed requests land on the same whole numbers, and Crisp names the rate you will actually get. Because it can only multiply, a 24fps clip asked for 60fps lands on 48, and the plan card says so rather than letting you discover it in the export. Ask for a rate your clip already meets or exceeds and it declines instead of interpolating: a 120fps file asked for 60fps is told Crisp can add frames to make motion smoother but cannot reduce a frame rate. That refusal is worth knowing about if your source is variable frame rate, where the reported rate and the real one can disagree.
One preset opts out entirely. The Max restore lane is generative and cannot also interpolate, so the app hides the Smooth motion control while Max is selected, the job endpoint rejects the pair, and the engine refuses with a message that tells you to turn Smooth motion off or use a standard preset. It is stated rather than silently dropped, which is the behaviour we want everywhere.
Smoother motion, in detail
Does interpolation add real detail?
No. It adds frames, not resolution. Every intermediate frame is built from the two real frames on either side of it, so the level of detail is unchanged. If you want more detail you want upscaling, which is a separate operation and can be run alongside it.
What multiplier should I use?
Doubling is the safe default and covers the common case of 30fps to 60fps. Larger multipliers give the motion estimator less to work with per generated frame, so artefacts become more likely. If you're interpolating for slow motion, shoot at the highest frame rate your camera allows first. Crisp's Smooth motion control offers Off, 2× and 3×; its API and command line accept 1, 2, 3 or 4 and reject anything else rather than rounding it.
Will it fix a video that stutters?
It depends on the cause. If the source has a genuinely low frame rate, interpolation helps. If it stutters because of a frame rate mismatch with the display, or because the file is variable frame rate and something resampled it badly, interpolation will smooth over the symptom without addressing the cause.
Does Crisp interpolate before or after upscaling?
After. Crisp runs the upscaler over a segment's frames first, and hands the already-upscaled frames to the interpolator. The order is fixed in the pipeline and is not a setting. It is the expensive order: the motion model is estimating over frames at output resolution, and Crisp's own disk-space check budgets working space for one plus the multiplier of output-sized frame sets per segment.
Can I interpolate and upscale in the same pass?
Yes on the standard presets, as two stages in a fixed order: upscale first, then interpolate the upscaled frames. The generative Max restore lane is the exception. It refuses the combination with its own message telling you to turn Smooth motion off or use a standard preset, the job endpoint rejects the pair, and the app hides the Smooth motion control while Max is selected.
Related
Download Crisp for Mac Free to try, one-time $129 to remove the watermark. Runs entirely on your Mac.