Open-source project
TianZerL/Anime4KCPP avatar
TianZerL/Anime4KCPP

Anime4KCPP lists eighteen build dependencies, six of which you must fetch yourself

A high performance anime upscaler

2,045 stars146 forksC++GPL-3.0

At a glance

What is it?
Anime4KCPP is a C++ anime upscaler with a command line tool, a Qt interface, a Python binding and video-host filters, built on one of three compute backends. Its build table is the interesting document: eighteen dependencies split between automatic and manual acquisition, and a browser-based demo that Microsoft Edge users are told to run with site security disabled.
Who is it for?
Sensible if you are building it yourself, since the accelerator backends and the video libraries are the parts you have to own, and the table tells you exactly which flags and path variables control each one. Two things to check first.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 134 days ago.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • TianZerL/Anime4KCPP2,045 ★ · +19
Star history
Repository2026-09-112026-11-15
TianZerL/Anime4KCPP2k2k

19 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Eighteen dependencies, and a column saying who fetches them

The build documentation is a single table with eighteen rows and five columns, and the column that matters most is the one saying where each dependency comes from.

Twelve are acquired automatically. The build system downloads and configures those on its own: the AviSynth SDK, the command line parser, the Windows multimedia base classes, the linear algebra library, the OpenCL SDK, the Python binding generator, a machine learning inference library, the single-header image loader, a PNG encoder, a half-precision float library, the VapourSynth SDK, and the test framework.

Six you fetch yourself. The CUDA toolkit. The four FFmpeg libraries, which are one option controlling four separate packages. And the Qt toolkit for the graphical interface.

That split is sensible. The automatically acquired items are small, pinned, and only needed at build time. The manual ones are large, licensed separately, and tied to a hardware vendor or a distribution. But the consequence is that the front page describes an automatic dependency fetch in one sentence and then hands you a table where two thirds of the rows say otherwise, so a first-time builder should read the table rather than the summary.

Three compute backends, fetched three different ways

The core can be built three ways, and each is a different kind of dependency.

The CUDA option is manual acquisition and is located with a package finder. The OpenCL option is acquired automatically and located the same way. The linear algebra option, a header-only matrix library, is also acquired automatically.

So the choice is between a vendor toolkit you install yourself, a cross-vendor SDK the build fetches for you, and a CPU-oriented header library the build fetches for you. That last one is the interesting case: the option named for a matrix library is the one that needs no GPU at all, and it is the fallback shape of the whole project.

The four FFmpeg libraries are structured the same way, behind a single option that gates all of them and a single path variable to point at them. That is the right design for a group that is always used together, and it means you either have a working FFmpeg installation at a known path or you do not.

The stated floors are a CUDA toolkit of version 11 or newer and FFmpeg 4 or newer, a C++17 compiler, and CMake. Both Qt 5 and Qt 6 are accepted.

Four ways to use it, and only one of them is in this repository

The build options describe four separate consumption surfaces.

A command line tool, gated by its own option and using a header-only argument parser. A graphical interface, gated by another option and needing the Qt toolkit you have to install yourself. A Python binding, gated by a third option and generated from a binding generator that is fetched automatically. And a browser playground compiled to WebAssembly.

The playground is the odd one. It is linked from the front page as a hosted page you can use to upscale images in your browser, and there is nothing in this repository to build it. The source tree is arranged by concern, with directories for the core, the command line tool, the interface, the filters, the binding, the video module, tests and tooling, and no WebAssembly target among them. The playground lives at a separate address under the same author's pages.

So the one surface a visitor is most likely to click is the one they cannot build from what they just cloned. The other three they can, and the first two of those are the ones the release binaries would be.

Edge users are told to disable site security for the demo

The playground link is followed immediately by a bolded instruction, and it is a security instruction:

> For the Microsoft Edge browser, to achieve optimal performance, you need to disable the Enhanced Security for the site.

That is the project's own advice, stated plainly, and it is worth taking at face value rather than skipping. Enhanced Security is a site isolation feature. Turning it off for a site means the browser stops isolating that origin from the rest of the browser, so anything running there has a wider blast radius than the default configuration intends.

The trade being offered is performance, which for a WebAssembly upscaler running entirely in the browser is a real constraint rather than a preference. Still, the ask is to weaken a browser boundary in exchange for speed, and the sentence frames it as a requirement rather than an option with a stated cost.

No equivalent note appears for other browsers, which suggests the constraint is specific to how Edge's sandboxing interacts with the threading this workload needs, and that other engines reach acceptable performance without it.

The Windows media base classes are a fork, for every compiler except one

One row in the dependency table points not at Microsoft but at a personal fork. The Windows multimedia base classes are a Microsoft sample archive, and the entry links a modified copy maintained under the same author as the project.

The note underneath explains when: for non-MSVC compilers, that modified version is what gets used. With Microsoft's own compiler, the original is used.

So the build quietly swaps out a first-party SDK for a third-party fork on every toolchain except one, and does so without making the reader opt in. That is a reasonable engineering decision, since those base classes are known not to compile cleanly outside a single compiler family, and the alternative would be no DirectShow filter on MinGW or Clang at all. It is also a place where a supply chain review has to look twice, because the dependency name in the table resolves to Microsoft's page and the code that actually compiles is somewhere else.

That filter is Windows only, and the compilers it is tested with are named as MinGW-w64, ClangCL and MSVC. The project is tested on Windows across MinGW-w64, Clang and MSVC generally.

Two build systems, three flag spellings, two license files

The Windows instructions give two complete command sequences, and they differ in more than the generator name.

The MinGW sequence uses the Makefiles generator, turns the OpenCL option on, and adds a second option to enable a static runtime:

powershell
mkdir build; cd build
cmake -G "MinGW Makefiles" .. -DAC_CORE_WITH_OPENCL=ON -DAC_ENABLE_STATIC_CRT=ON
cmake --build . --config Release -j8
cd bin
./ac_cli -v

The MSVC sequence uses the Visual Studio 2022 generator and turns the OpenCL option on, with no second option.

That difference is not cosmetic. The static runtime option is what stops the resulting binary from needing a matching runtime installed on every machine it runs on, so the MinGW build produces something more portable than the MSVC build, and nothing on the page says that is a deliberate difference rather than an oversight.

The repository root carries two licence files, one GPL and one MIT, which is the normal arrangement for a project whose bindings can be used under different terms than its core. The default branch is master and the primary language is C++, which the build table confirms by requiring a C++17 compiler before anything else.

Nine minor versions of churn and then a five month gap

Three tags are visible and the gaps between them are the story.

A 2.x tag in January 2021. A 3.0.0 tag in August 2025, a version bump that signals a deliberate break rather than an increment. And a 3.2.0 tag in May 2026.

So the 2.x line ran for years, the project reset its major version once, and then the 3.x line has produced a handful of minor tags over the following year. The last commit is dated July 2026.

The front page describes the current version as CNN based and says it aims to be simple and efficient, which is a change of emphasis from what the older line was known for. Nothing in the visible documentation explains the algorithm, the model, or what the version 3 reset removed, which for anyone upgrading from a 2.x install is the first thing to look up and the thing this page does not answer.

Editorial conclusion

Sensible if you are building it yourself, since the accelerator backends and the video libraries are the parts you have to own, and the table tells you exactly which flags and path variables control each one. Two things to check first. Decide which compute backend you actually want, because picking the wrong one is a large rebuild rather than a runtime switch. And if you were planning to use the browser demo, read what it asks you to disable before you do.

Frequently asked questions

How do I use Anime4KCPP?

The project ships a command line tool, a Qt graphical interface, a Python binding and video host filters, each behind its own build option. The build documentation gives complete command sequences for Windows with two different compilers, and the tool itself is verified by running ac_cli with the version flag after building.

What are the minimum dependency versions for building Anime4KCPP?

A CUDA toolkit of version 11 or newer if you use that backend, FFmpeg 4 or newer for the video module, VapourSynth SDK 4 if you build that filter, a C++17 compiler, and CMake. Both Qt 5 and Qt 6 are accepted for the graphical interface.

Which compute backends can Anime4KCPP be built with?

Three, each behind its own option: a CUDA toolkit fetched manually, an OpenCL SDK fetched automatically, and a header-only linear algebra library also fetched automatically. The last is the option that needs no accelerator hardware.

Why does the Anime4KCPP browser demo tell Edge users to change a security setting?

The front page states that for Microsoft Edge, optimal performance requires disabling the site's Enhanced Security. That is the browser's site isolation feature, and the note appears only for Edge, with no equivalent instruction for other browsers.

Official sources

  1. Issues
  2. License: GPL-3.0
  3. README
  4. Releases
  5. TianZerL/Anime4KCPP on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tianzerl-anime4kcpp.svg)](https://hysenlabs.com/projects/tianzerl-anime4kcpp)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tianzerl-anime4kcpp.svg)](https://hysenlabs.com/projects/tianzerl-anime4kcpp)

Was this useful?