Final2x: a cross-platform super-resolution desktop app built on Electron and a Python core
a cross-platform image super-resolution tool
At a glance
- What is it?
- Final2x wraps Python super-resolution models in an Electron interface. It is a desktop tool first, and the README is honest about the friction of getting it running on each platform.
- Who is it for?
- Final2x suits people who want a graphical batch 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.
- Can I use it commercially?
- Yes. BSD-3-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 7 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 17, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
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 the repository topics list electron, vue3, pytorch, super-resolution and i18n. That combination 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-dev, while the most recent release listed is v4.0.0 from 2025-10-05. The README's news section states that v4.0.0 "uses the cccv backend, supporting custom models and more", and links to a separate repository, cccv_demo_remote_model, as a custom model demo. Custom model loading is therefore the headline change in the current major version.
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 "now live in core and are released with the desktop app under the same 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 packageManager pnpm@10.17.1 and engines of node >=18 and pnpm >=8, 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 frontend is Vue 3, with naive-ui for components, pinia for state, and pinia-plugin-persistedstate for persistence, so settings survive a restart. Internationalisation comes from @intlify/unplugin-vue-i18n, matching the i18n topic on the repository.
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.9 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 from here." 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 "the versions available through package managers may not always be the latest".
On macOS, the README gives two commands to run once, because the app is not notarised in a way Gatekeeper accepts by default:
sudo spctl --master-disable
xattr -cr /Applications/Final2x.appThe first disables Gatekeeper globally, which is a blunt instrument and affects every application on the machine, not just this one. The second strips the quarantine attribute from the app bundle. The README then says to allow applications downloaded from anywhere in System Preferences, under Security and Privacy, General. If you are not comfortable disabling Gatekeeper system-wide, the alternative is to allow the single app in that settings pane and skip the first command.
Linux is the platform where the core has to be installed separately. The README requires Python >= 3.9 and PyTorch >= 2.0, then:
pip install Final2x-core
Final2x-core -h # check if the installation is successful
apt install -y libomp5 xdg-utilsThe 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; the README does not document a first-run wizard, so expect the settings to be the model selection and output path controls visible in the screenshots.
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
The macOS instructions are the clearest limitation. Telling users to run sudo spctl --master-disable turns off Gatekeeper for the whole system. That is a real security trade-off, and the README presents it without qualification. A user who follows it and forgets to re-enable Gatekeeper has weakened their machine for the sake of one application.
On Linux, the dependency chain is the second obstacle. Requiring Python >= 3.9 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; it only notes in the v3.0.0 news item that Nvidia 50 series GPUs are supported from that release onward.
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. Since v4.0.0 changed the backend to cccv, an out-of-date package could leave you on the old model format entirely. 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
The related searches for this project name Upscayl, Waifu2x and chaiNNer, 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. That split is what lets it load custom models through the cccv backend in v4.0.0, 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 and, in the searches, with GIF handling. Final2x is the broader tool: the repository topics include low-level-vision and computer-vision, and the i18n support suggests a general audience rather than one art style. If your input is animated GIFs, the searches suggest that is a Waifu2x question; 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-09-10, six days before this article. That is recent activity, but the release cadence is slower than the commit cadence: v4.0.0 landed on 2025-10-05, v3.0.0 on 2025-08-16, and v2.1.0 on 2024-12-14. The package.json version is 4.1.0-dev, so a 4.1 line is in progress but unreleased.
The upgrade cost is concentrated in the v3 to v4 jump. Because v4.0.0 introduced the cccv backend and custom model support, the model format and the loading path changed. Anyone who built a set of model files against v3 should expect to re-verify them after upgrading. 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 v4.0.0 release notes is the only documented way to know what changed.
Editorial conclusion
Final2x suits people who want a graphical batch 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 v4.0.0 release notes for the cccv backend change, 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
How do I install Final2x on Linux?
Download the desktop app from the releases page, then install the Python core with pip install Final2x-core after confirming Python >= 3.9 and PyTorch >= 2.0 are present. The README also asks you to run apt install -y libomp5 xdg-utils, and suggests Final2x-core -h to verify the core installation.
Does Final2x support custom models?
Yes, from v4.0.0 onward. The README states that v4.0.0 uses the cccv backend and supports custom models, and links to the cccv_demo_remote_model repository as a demonstration.
Which platforms does Final2x run on?
Windows, macOS and Linux, according to the platform badges and the installation section of the README. Windows builds can also come from winget or scoop, though the README warns those versions may not always be the latest.
Community notes