Final2x: a cross-platform super-resolution desktop app built on Electron and a Python core

What Final2x solves, and who it is for

Upscaling an image with a neural model normally means writing a Python script, picking a model file, and handling the tensor plumbing yourself. Final2x packages that work into a desktop application. The README describes it as "A cross-platform image super-resolution tool", and it is listed for Windows, macOS and Linux. That tells you the intended audience: someone who wants model-based upscaling through a graphical interface, on Windows, macOS or Linux, without assembling the inference code.

The project is written primarily in TypeScript, with a Python component under core/. The package.json describes the product name as Final2x and the version as 4.1.0, and the most recent release listed is v4.1.0 from 2026-09-30. The README says "Use built-in models or load your own", links to a separate repository, cccv_demo_remote_model, as a custom model demo, and lists cccv as the image restoration and super-resolution backend.

It is not aimed at server-side batch processing. There is no documented HTTP API, and the README's installation path is a downloaded release binary, not a container image or a service. If your job is to upscale ten thousand images on a build machine, the desktop shell is overhead you would have to work around.

How the Electron shell and the Python core fit together

The top level of the repository separates the two halves clearly. src/ and the electron-vite configuration files belong to the desktop application; core/ holds the Python CLI and desktop backend, and the README states that these "live in core and share the desktop app's version number". A script named version:check runs python scripts/check_version.py, which suggests the two version numbers are kept in step by tooling rather than by hand.

The build system is pnpm-based. package.json declares devEngines of node >=24 and pnpm >=12.0.0, and the workspace is defined by pnpm-workspace.yaml. The main entry is ./out/main/index.js, which is the compiled Electron main process produced by electron-vite build. The README credits naive-ui among the projects it builds on, and internationalisation comes from @intlify/unplugin-vue-i18n in the dependencies.

The practical consequence of this split is that the heavy computation is not in JavaScript. The Electron process orchestrates; the Python core performs inference with PyTorch. That is why the Linux instructions require Python >= 3.10 and PyTorch >= 2.0 before anything will upscale. On Windows and macOS the release build is expected to carry what it needs, but the README does not spell out how the bundled interpreter is handled, so treat the packaged runtime as opaque unless you read the build scripts.

Installing Final2x and running a first upscale

The README's installation section points to the releases page first: "Download the latest release for your platform." That is the shortest path on any platform. Windows users are told they can also use a package manager such as winget or scoop, with the caveat that "Package manager versions may lag behind the latest release."

On macOS, if the app is blocked on first launch, the README says to run this command in Terminal after placing it in /Applications:

xattr -cr /Applications/Final2x.app

It strips the quarantine attribute from the app bundle.

Linux is the platform where the core has to be installed separately. The README requires Python >= 3.10 and PyTorch >= 2.0, then, on Debian or Ubuntu:

pip install Final2x-core
Final2x-core -h # Verify the backend installation
sudo apt install -y libomp5 xdg-utils

The pip package is named Final2x-core, and running it with -h is the documented way to confirm the install worked. The apt line pulls in libomp5, the OpenMP runtime that PyTorch's CPU kernels link against, and xdg-utils, which Electron uses for desktop integration on Linux. After that, launch the desktop app and load an image.

Building from source instead of downloading a binary means pnpm. The scripts include dev for electron-vite dev, build for electron-vite build, and per-platform packaging targets such as build:linux-x64 and build:win-x64, all of which pass --publish=never. The postinstall hook runs electron-builder install-app-deps, so native dependencies are rebuilt against the Electron ABI after pnpm install.

Where Final2x gets in your way

On macOS, the app may be blocked on first launch, and the README's workaround is to run xattr -cr /Applications/Final2x.app.

On Linux, the dependency chain is the second obstacle. Requiring Python >= 3.10 and PyTorch >= 2.0 before the app is useful means the desktop binary alone is not sufficient. Anyone on a distribution with an older system Python, or on a machine without a working PyTorch wheel for their GPU, will hit that wall. The README does not document a fallback to CPU-only inference, nor does it list which CUDA versions are supported either.

There is also a packaging gap. The README says package manager builds may lag the latest release, which means a winget or scoop install can silently give you an older major version with different model support. Neither the README nor the release list documents a rollback procedure, so if a new version breaks your workflow, downgrading means finding the older release asset yourself.

Finally, the repository does not document a headless mode. The Python core is released as a CLI, and Final2x-core -h is shown as a smoke test, but the README does not describe its arguments or batch behaviour. Treat the CLI as undocumented rather than as a supported automation surface.

Final2x against Upscayl, Waifu2x and chaiNNer

Upscayl, Waifu2x and chaiNNer are common alternatives, so the comparison is worth making concrete. All four do model-based upscaling, and they differ in where the model runs.

Upscayl is the closest match in shape: a desktop application for upscaling images. The difference visible from here is the runtime. Final2x splits into an Electron front end and a Python core that the README says must be installed separately on Linux with pip install Final2x-core. The README lists cccv as its backend and says you can load your own models, but it also means the Linux install is two steps, not one.

Waifu2x is the older, narrower ancestor of this whole category, associated with anime-style artwork. Final2x is the broader tool: the README describes cccv as an image restoration and super-resolution backend. The Final2x README does not mention GIF support at all.

chaiNNer is the node-graph option. It exposes the model pipeline as a visual graph you wire together, which is a different mental model from Final2x's fixed application flow. If you need to inspect or rearrange the steps between input and output, a graph editor is the more direct answer. Final2x gives you a chosen model and an output path, and the README documents nothing beyond that.

The honest summary: pick Final2x when you want a packaged desktop app with a Python inference core and custom model support. Pick something else when you want a headless pipeline, a node graph, or a single-file install on Linux.

Licence, maintenance and upgrade cost

Final2x is licensed under BSD 3-Clause, and the README points to the LICENSE file at the repository root. That is a permissive licence, so redistribution and modification are allowed subject to its conditions, which include retaining the copyright notice and the disclaimer. The README does not discuss the licences of the bundled models or of the cccv backend, and those are separate works; if you plan to redistribute a build, check the model files and the cccv repository independently. Nothing here is legal advice.

The repository is not archived, and the last push was on 2026-11-02. Recent releases are v4.1.0 on 2026-09-30, v4.0.0 on 2025-10-05 and v3.0.0 on 2025-08-16, and the package.json version is 4.1.0.

The version:check script and the CI workflows named CI-test, CI-test-core, CI-build and Release suggest the maintainers gate releases on tests, but the README does not describe a migration guide, so reading the release notes is the only way to know what changed.

Editorial conclusion

Final2x suits people who want a graphical upscaler rather than a Python script, and who are willing to install Python and PyTorch on Linux to get the core working. It is the wrong choice if you need a headless pipeline on a server, since the shipped product is a desktop application. Before adopting it, check the latest release notes, confirm the package manager builds of your platform are current, and verify that your GPU is covered by the PyTorch build you install.

Frequently asked questions

Official sources

1. EutropicAI/Final2x on GitHub
2. Issues
3. License: BSD-3-Clause
4. README
5. Releases