chaiNNer: a node-based image processing GUI for chaining upscales and batch jobs

What chaiNNer solves, and who it is actually for

Most image processing tools hide the pipeline. You pick a filter, you get an output, and the sequence of operations that produced it lives only in your memory. chaiNNer makes that sequence explicit: the README describes it as a node-based image processing GUI aimed at making chaining image processing tasks easy and customizable, and it says the project was born as an AI upscaling application before growing into a more general programmatic image processing application.

The people who get value from that are not casual users. They are the ones running the same upscale across a folder of images, or the same denoise, resize and save sequence across a video, and who need to change one parameter in the middle without rebuilding everything. The README points to Kim's chaiNNer Templates for people who are still new, which is a fair signal: the tool assumes you will eventually want to see and edit the graph, not just press run.

It is a poor fit for someone who wants a single upscale button. The README is explicit that before you can run anything you need to install one of the neural network frameworks from the dependency manager, and the editor starts empty. That is a real setup cost, and it is deliberate.

How the node graph and the Python backend fit together

The repository layout separates a TypeScript frontend from a Python backend. The top level holds src/, backend/, vite/ and forge.config.js, and package.json names electron-forge as the build and run tool. The main entry is .vite/build/main.js, and the development scripts start an Electron process against a remote backend at http://127.0.0.1:8000.

The backend is a Python program. The dev:py script changes into backend/src and runs run.py with port 8000 and a --dev flag. That is the whole architecture in one line: the Electron window is a client, and the Python process is where the actual image work happens. The README's claim that chaiNNer downloads an isolated integrated Python build on startup follows from this, since the frontend needs a Python interpreter to talk to.

Connections between nodes are typed. The README states that each handle is color-coded to its specific type, and that while connecting you are shown only the compatible connections. That type system is what makes the graph usable at scale, and it is also what produces the most common early frustration: a handle that will not accept your drag is telling you the data types do not match, not that the program is broken.

Batch iteration is handled by specific nodes rather than by the graph as a whole. Load Images iterates a folder, Load Video iterates frames, and the README warns that you cannot use both in the same chain. Collector nodes such as Save Image and Save Video can be combined with the opposite loader, so the restriction is on iteration, not on output.

Installing chaiNNer and running a first upscale

The README gives one installation path: download the latest release from the GitHub releases page and run the installer for your system. You do not need Python installed, because chaiNNer downloads an isolated integrated Python build on startup. If you insist on your system Python, the setting exists, and the README requires Python 3.10 or later with 3.11+ recommended.

After the app launches, the first real step is the Dependency Manager, reached from the button in the upper-right-hand corner. This is where you install PyTorch, NCNN, ONNX or TensorRT. For Nvidia users the README names PyTorch or TensorRT as the preferred upscaling path; for AMD users it names NCNN, or PyTorch with ROCm on Linux.

With a framework installed, build the chain. Node names are dragged or double-clicked from the selection panel into the editor, and handles are connected by dragging from one to another. The README's own screenshot shows a minimal upscale chain: a Load Image node feeding an upscale node, whose output goes to a save node. Once the chain is connected, press the green run button in the top bar. The README states that the connections between nodes become animated and un-animate as they finish processing, and that the red stop and yellow pause buttons control a running chain.

For a folder rather than a single file, swap the loader. The README says to use the Load Images node for batch processing on a folder of images and the Load Video node for video. Remember the restriction: Load Images and Load Video cannot both appear in one chain.

Where chaiNNer breaks, and the cases it is the wrong tool for

The compatibility notes are the most honest part of the README. macOS 10.x and below are not supported. Windows 8.1 and below are not supported. Apple Silicon is supported with PyTorch MPS acceleration, but ONNX only supports the CPU Execution Provider there, and NCNN may not work properly on some configurations. That means an M-series Mac user who wants ONNX acceleration has no path to it.

The second failure mode is documented as all-black outputs for some NCNN users with non-Nvidia GPUs. The README attributes it to the graphics driver crashing after running out of memory and says the author is not sure how to fix it, suggesting manually setting a tiling amount as the workaround. This is a real limitation, not a configuration mistake, and it lands hardest on exactly the AMD users the README recommends NCNN to.

The third is structural. Because batch iteration comes from a loader node, you cannot mix image-folder iteration and video-frame iteration in one chain. If your job is "upscale every frame of this video and also every still in this folder with the same graph," you build two chains.

Finally, there is the setup barrier itself. The README states plainly that you must install a neural network framework before the upscale example works. Anyone expecting to open the app and upscale a file immediately will be disappointed.

chaiNNer compared with ComfyUI

The comparison people search for is chaiNNer versus ComfyUI, and the difference is in what the graph is for. ComfyUI is built around diffusion model inference: its node graph describes a generation pipeline, with sampling, conditioning and latent space as first-class concepts. chaiNNer's graph describes image processing operations, with upscaling as the original use case and general manipulation as the growth area.

That shows up in the dependency story. chaiNNer's Dependency Manager offers PyTorch, NCNN, ONNX and TensorRT, and the README frames the choice around which GPU you have and which model architectures you want to run. The application is also explicitly cross-platform, with the README stating you can run it on Windows, MacOS and Linux, and it ships as an Electron desktop app with an installer rather than a server you reach through a browser.

If your work is super-resolution models, denoising, resizing and batch file processing, chaiNNer's node set maps more directly onto the task. If your work is generating images from prompts, the graph in chaiNNer is not aimed at that at all. The two tools overlap on the word "node" and very little else.

Licence, maintenance and what upgrading costs

chaiNNer is licensed under GPL-3.0, per the LICENSE file and the repository metadata. That matters if you plan to bundle it, ship a modified build, or link it into a commercial product, because the GPL's copyleft terms attach to distributed derivative works. This is not legal advice; if redistribution is part of your plan, read the licence text and talk to someone qualified.

The release history is uneven. v0.25.0 landed on 2025-10-19 and v0.25.1 on 2025-10-23, but the previous release, v0.24.1, dates to 2024-06-07. That is a gap of roughly sixteen months between the 0.24 and 0.25 lines. The repository itself is not archived and the last push was on 2026-09-19, so work is happening on main even when tagged releases are quiet.

All releases are labelled alpha, including v0.25.1. Treat every version as a moving target and expect breakage across minor numbers. The README also points to nightly builds for people who want the latest changes, which is a second channel to track if you need a fix that has not been tagged.

Upgrade cost is mostly in the dependency layer, not the app. Because chaiNNer manages its own integrated Python and installs frameworks through the Dependency Manager, a version bump can mean reinstalling or re-resolving a backend. Budget for that, and pin the release you validated against rather than tracking latest.

Editorial conclusion

Adopt chaiNNer if you want a visible, editable pipeline for upscaling or batch image work and you are willing to install a neural network framework from the Dependency Manager first. Skip it if you need a single button that upscales a file, or if you are on macOS 10.x, Windows 8.1 or older, or an AMD GPU on Windows where NCNN is the only path. Before committing, verify three things on your own hardware: that your GPU backend produces non-black output at your chosen tile size, that the Load Images and Load Video nodes you need are not required in the same chain, and that the GPL-3.0 licence fits how you intend to redistribute anything you build around it.

Frequently asked questions

Official sources

1. chaiNNer-org/chaiNNer on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases