# The code is complete and the binaries are the product

> Flowframes is a Windows GUI for video interpolation that wraps RIFE, DAIN and FLAVR. The repository says its source is complete and does not paywall people who compile it, while also stating that it provides no builds and no support for self-built versions.

**n00mkrad/flowframes** — Flowframes Windows GUI for video interpolation using DAIN (NCNN) or RIFE (CUDA/NCNN)

- Repository: https://github.com/n00mkrad/flowframes
- Stars: 2,085 · Forks: 161
- Language: Python
- License: GPL-3.0
- Published: 2026-10-12 · Updated: 2026-10-12 · Language: en
- Canonical page: https://hysenlabs.com/projects/n00mkrad-flowframes

## Open source with the builds withheld

The funding model is stated in the first paragraph and it is unusual enough to read twice. Flowframes is described as open-source donationware, where builds are released for free on itch after an early-access period on Patreon. The repository's code is complete and, in the author's words, does not paywall experienced users who want to compile the program themselves or contribute to development. In the same breath, the README says the author does not provide support for self-built versions, because the code cannot be guaranteed stable at any given moment. So the division is deliberate and consistent: source is open and unrestricted, binaries are the thing the project distributes, and the guarantee attaches to the distributed binaries rather than to the repository. The quick installation section repeats the first half by saying to download from itch, or from Patreon for the most recent beta versions, and that this repo does not provide builds at all.

## Three models, two backends, and a clear hardware rule

The application supports RIFE through both Pytorch and NCNN, DAIN through NCNN, and FLAVR through Pytorch. That is the full engine list, and the FAQ reduces the backend choice to a hardware question. RIFE-NCNN runs on Tencent's NCNN framework, which allows it to run on any modern Vulkan-capable GPU, while the official RIFE implementation runs best through its original Pytorch implementation. The stated answer to which one to use: the results should be identical, RIFE-NCNN also runs on AMD cards, CUDA only on Nvidia, and if you have an Nvidia card use CUDA because it is faster. Running a Pytorch implementation therefore needs a modern Nvidia GPU from the 750 Ti and the 900 through 4000 series, plus a Python installation with Pytorch 1.5 or later and the opencv-python, sk-video and imageio packages. The installer downloads those dependencies automatically when they are missing, which is the difference between the packaged install and a manual setup.

## De-duplication is the setting people get wrong

Frame de-duplication exists because 2D animation has consecutive identical frames, and interpolating across them produces choppy output. The FAQ is unusually blunt about the failure case: if your output looks very choppy, especially in dark or low-contrast scenes, disable de-duplication or reduce the threshold if you still need it. The reasoning is in the setting's own description. It is meant for 2D animation, and the README says to disable it completely for content without duplicates such as camera footage or CG renders. The two modes differ in implementation and in accuracy. During Extraction uses ffmpeg's mpdecimate filter and never extracts the duplicate frames at all, which works for most content. Accurate, or After Extraction, extracts all frames first and then checks for duplicates by measuring image difference with Magick.NET, which is slower and gives you a threshold you can tune. So the default is fast and approximate, and the accurate mode exists for the cases where that is not good enough.

## Scene changes and loops are two settings aimed at different artefacts

Two settings exist because interpolation applied blindly produces recognizable artefacts. Fix Scene Changes avoids interpolating cuts, on the stated grounds that doing so produces a weird morphing effect across the transition. That is a correctness setting: a cut is not an intermediate frame, and a model asked to produce one will invent motion that was never there. Loop Interpolation is a different kind of setting, aimed at looping animations, where the last frame is interpolated back toward the first so the loop closes perfectly. Related to both is Minimum Video Length under export, which loops the output to reach a minimum duration, and Maximum Output Frame Rate, which limits the result by downsampling rather than interpolating, which is how you get a 60 FPS file from 24 FPS source. Processing Style is the coarsest of these controls: run every step at once, or step through manually when you want to edit frames or deduplicate by hand.

## AI settings expose the backend directly

The AI-specific settings are the ones that require you to know which engine is running. RIFE UHD Mode changes some scaling parameters and is meant to improve results on high resolution video. GPU IDs take a comma separated list, where 0 is the default for a single dedicated GPU and four dedicated GPUs would be 0,1,2,3. NCNN Processing Threads can be raised to 2, 3 or 4 to improve GPU utilization, with the stated trade that it can also slow things down. RIFE CUDA Fast Mode uses half precision, fp16, to speed things up and reduce VRAM usage, and the README says plainly that it can be unstable. That last one is the setting to turn off first when diagnosing artifacts. For debugging, Show Hidden CMD Windows reveals the command windows for AI processes, which is how you see what the sub-processes actually are.

## Requirements are Vulkan first and CUDA second

The system requirements section is split in a way that encodes the engine decision. The minimum is a Vulkan-capable GPU, given as Nvidia Kepler or newer or AMD GCN 2 or newer, which is the NCNN path. The recommended set is a modern CUDA-capable GPU, Nvidia Maxwell or newer, with 6 GB of VRAM or more, 16 GB of RAM, and a modern CPU described as Intel Core 7000 series or newer or AMD Ryzen 1000 series or newer. So the minimum configuration can run the AMD path and the recommended one is written for the Nvidia path. The memory figure is worth connecting to the settings above: half precision exists to reduce VRAM usage, and Auto-Encode exists to avoid keeping every frame on disk, which is a second memory concern that is about disk rather than the card. Storage pressure is handled in export settings as well, with an option to delete already encoded frames while interpolating to minimize disk usage.

## Where Flowframes is the wrong tool

Four cases. The first is a Linux or macOS user. Every system requirement and install instruction here is Windows, and the packaged build is a Windows installer, so the only route elsewhere is compiling it yourself, which the author explicitly declines to support. The second is real-time playback. This is an offline pipeline that exports a file, and the options around maximum output frame rate and encoding are about producing a result on disk rather than playing smoothly. The third is someone who needs a documented, reproducible build. The author states that the code cannot be guaranteed stable at any given moment and provides no support for self-built versions, which is an honest answer and an awkward one if you need a version you can file a bug against. The fourth is a project where source footage must not be transformed this way. Interpolating raises the effective frame rate by generating frames, so a scene that has never existed is now in the output, and the settings around scene changes and de-duplication are there to keep that from looking wrong rather than to avoid it.

## Conclusion

Flowframes suits a Windows user with a capable GPU who wants interpolated video without running a Python pipeline by hand, particularly for 2D animation where frame de-duplication matters. It does not suit a Linux or macOS user, nor someone who needs a stable build they can raise a bug against themselves. Before adopting, decide between the CUDA and NCNN engines on your hardware, turn de-duplication off for camera footage, and accept that the author states no support is provided for self-built versions.

## FAQ

### Where do I download Flowframes?

From itch for free builds, or from Patreon for the most recent beta versions. The repository itself does not provide builds, though the source is complete and unrestricted for anyone who wants to compile it.

### Should I use RIFE CUDA or RIFE NCNN?

The FAQ says results should be identical. NCNN runs on AMD cards as well, CUDA only on Nvidia, and if you have an Nvidia card CUDA is the faster choice.

### Why does my interpolated video look choppy?

The FAQ points at de-duplication: disable it, or reduce the threshold if you still need it. It is meant for 2D animation with repeated frames and should be off for camera footage or rendered video.

### What is the difference between the two de-duplication modes?

During Extraction uses ffmpeg's mpdecimate filter and does not extract duplicate frames at all. Accurate, or After Extraction, extracts everything first and then compares frames using Magick.NET, which is slower but more accurate and flexible.

### What GPU does Flowframes need?

The minimum is a Vulkan-capable GPU, Nvidia Kepler or newer or AMD GCN 2 or newer. Recommended is a CUDA-capable Nvidia Maxwell or newer card with 6 GB of VRAM or more, 16 GB of RAM and a modern CPU.

### How do I switch from the bundled Python to my own?

Delete the py-tu or py-amp folder, whichever you have, from FlowframesData/pkgs/. Flowframes will then try to use the system Python installation.

## Sources

- [Issues](https://github.com/n00mkrad/flowframes/issues)
- [License: GPL-3.0](https://github.com/n00mkrad/flowframes/blob/main/LICENSE)
- [n00mkrad/flowframes on GitHub](https://github.com/n00mkrad/flowframes)
- [README](https://github.com/n00mkrad/flowframes/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/n00mkrad-flowframes