open-photo-ai

Open Photo AI (OPAI)

Open Photo AI is an open source alternative to the popular photo AI editor.
It currently supports the following enhancements:

💡 Motivation

There are many excellent AI-based photo editing tools available today, ranging from open-source solutions – often powerful but complex to set up and use, such as ComfyUI – to commercial products that favor ease of use over deep customization, like those from Topaz Labs.

I have long used both ComfyUI and Topaz Labs solutions, choosing between them depending on the task. Recently, however, Topaz Labs moved from a perpetual license to a subscription-based pricing model, a change I strongly dislike. As a developer, I am happy to pay for software that is useful for me, whether open source or proprietary, but I believe subscription models are rarely designed to benefit users and instead primarily serve company interests.

That is why I created this project: an open-source alternative to Topaz Photo AI. It may never match the same level of polish or performance – Topaz has teams of full-time engineers, while this is a solo project built in my spare time – but I have ambitious goals and aim to reach feature parity with their product over time.

⬇️ Installation

This app has versions for Windows, macOS, and Linux. Download the latest release that matches your computer architecture and operating system.

However, the recommended (and easiest) way to install Open Photo AI is using one of the following scripts; copy and paste the command below in the terminal, and the script will automatically detect and install the correct version of the app:

macOS & Linux

curl -fsSL https://vegidio.github.io/open-photo-ai/install.sh | sh

Windows (PowerShell)

irm https://vegidio.github.io/open-photo-ai/install.ps1 | iex

Choosing what to install

By default the scripts install both the GUI and the CLI. Set OPAI_INSTALL to gui or cli to install only one of them:

# macOS & Linux
curl -fsSL https://vegidio.github.io/open-photo-ai/install.sh | OPAI_INSTALL=cli sh

# Windows (PowerShell)
$env:OPAI_INSTALL='cli'; irm https://vegidio.github.io/open-photo-ai/install.ps1 | iex

🖼️ Usage

There are two ways to use Open Photo AI: using the GUI or the CLI.

The GUI is the easiest way to use the app, with an intuitive interface that allows you to enhance images with just a few clicks. The CLI is more advanced and allows you to enhance images in a more automated way.

GUI (video 🎥)

1. Click on the button Browse images to select one or more images that you would like to enhance.
2. The images are enhanced automatically or manually depending on the toggle Autopilot in the top right side of the screen:
   • If enabled, the app will automatically analyse the images and suggest enhancements for them.
   • If disabled, you will need to select the enhancements yourself, using the button Add enhancement.
3. Select one or more images that you would like to export on the image drawer at the bottom of the screen.
4. Click on the button Export image, select the location and image format, then click on Export.

CLI

The CLI enhances one image per command:

opai <input> <enhancement flags...> [--quality hd|sd] --output <file>

For the complete reference of how to use the CLI, see the CLI Reference.

Examples:

# Upscale using the default model, at the scale the photo needs
opai photo.jpg --up -o photo-large.png

# Restore faces using the default model, then upscale 2x with Kyoto, and save as WebP
opai portrait.jpg --fr --up kyoto --scale 2 -o portrait.webp

# Upscale with Osaka using its SD quality
opai scan.png --up osaka -q sd -o scan.avif

# Denoise twice as strongly with Gothenburg, then adjust light with Paris
opai night.jpg --dn gothenburg --dn-str 200 --la --la-bias -20 -o night-clean.jpg

💻 System Requirements

The app runs on any of these systems even without a GPU, falling back to the CPU when no supported accelerator is found; it will just be much slower.

NVIDIA acceleration (CUDA & TensorRT)

On Windows x64 and Linux, the app can use CUDA and TensorRT for the best performance. For that you need:

• A GTX 16xx, RTX 20xx or newer GPU (compute capability 7.5+). Older cards, like the GTX 10xx series, still work, but through the slower WebGPU acceleration.
• A recent NVIDIA driver with support to CUDA 13 (version 580 or newer).
• At least 6 GB of VRAM; 8 GB or more is recommended.

Osaka upscaler

Osaka is a much heavier model than the others and has its own requirements: at least 32 GB of RAM and a GPU with 16 GB of VRAM on Windows and Linux, or 16 GB of unified memory on macOS. It also takes about 7 GB of extra disk space.

✨ Enhancements

All enhancements available here come from open-source AI models that were adapted and converted to work on this project. The models and the credits to the original works can be found in the Hugging Face repository vegidio/open-photo-ai:

Denoise

• Stockholm: use when you need fast, high-quality denoising of real sensor noise and computational efficiency matters. It’s a good choice when throughput and resource constraints are real concerns, keeping inference times low without sacrificing quality.
• Gothenburg: use when your photos contain real-world sensor noise, the kind produced by shooting in low light or at high ISO with a smartphone or DSLR. It handles complex noise patterns that cameras produce, making it the right choice for photography.
• Malmö: use to remove rain streaks from outdoor images, whether captured in light drizzle or heavy downpour. It handles rain of varying scale, density, and direction, restoring fine details behind streaks. A good choice when weather artifacts obscure the scene.

Verdict: for regular sensor noise, start with Gothenburg for the best quality, then switch to Stockholm if speed matters more; reach for Malmö only when you need to remove rain streaks.

Face Recovery

• Athens: use when identity fidelity matters most. This model lets you preserve facial structure while restoring details, even on heavily degraded faces. Best when you want restoration without changing the person.
• Santorini: use when you want aggressive, fast enhancement and can tolerate identity drift. It produces sharp, visually pleasing faces on moderate degradation, but may hallucinate features and alter identity on very low-quality inputs.

Verdict: if identity matters, start with Athens; if aesthetics matter more, use Santorini.

Colorization

• Delhi: use as your first choice for most black-and-white photos. It looks at the whole scene to decide what things should look like, producing rich, confident colors with clean edges — skin, skies, and clothing rarely bleed into each other. Occasionally it commits boldly to a color that wasn’t there.
• Mumbai: use when Delhi’s colors feel too intense or modern for the photo. Built on the same engine but trained for a more creative touch, it leans toward softer, gently stylized tones that can suit vintage portraits and film scans — though its choices vary more from one photo to the next.
• Jaipur: use when consistency matters most. Its colors are more muted and restrained than the others, but it almost never produces the odd color patches or strange guesses colorization is prone to, making it a steady choice for old family portraits, landscapes, and badly degraded scans.

Verdict: start with Delhi for the most lifelike result; try Mumbai if you’d like a softer, more nostalgic feel; switch to Jaipur when the other two hallucinate colors or leave strange patches on a difficult photo.

Light Adjustment

• Paris: use when the light in the photo is uneven — night scenes, backlit subjects, or a face lost in shadow while the rest looks fine. It brings back what the darkness hides, keeps colors natural, and is very fast.
• Lyon: use when the whole photo came out too bright or too dark — washed-out skies, or a subject that disappears into shadow. It rebuilds the brightness of the entire image, rescuing detail at both ends at once.

Verdict: reach for Paris when only parts of the photo are too dark and you want them opened up; switch to Lyon when the whole shot is over- or under-exposed and the brightness needs fixing from end to end.

Color Balance

• Rio: use when the whole photo leans one way — orange under indoor lamps, blue in open shade or on a cloudy day. It re-renders the shot as if the camera had picked the right white balance, correcting the cast globally.
• São Paulo: use when two light sources fight inside the same frame, like a warm lamp indoors against daylight from the window. It renders the scene under several white balances and blends them pixel by pixel, area by area.

Verdict: start with Rio: most photos lean the same wrong way and it’s the faster of the two; switch to São Paulo when fixing one part of the frame throws another off, which no single global correction can solve.

Sharpen

• Moscow: use when blur comes from the camera being out of focus rather than from movement — e.g. portraits with a blurry background or foreground, macro photography gone soft, or any scene where a lens failed to focus on the right plane.
• St. Petersburg: use when you need fast, lightweight motion deblurring and efficiency matters more than squeezing out every last bit of quality. It’s well-suited for action footage and handheld camera shake, and it’s a solid choice when running on limited hardware.
• Novgorod: use when blur is caused by camera shake or fast-moving subjects — e.g. sports, handheld shots in low light, or any photo where something moved during exposure. It prioritizes maximum restoration quality over speed; good when results matter most.

Verdict: use Moscow for out-of-focus blur; for motion blur, start with Novgorod for the best quality, or fall back to St. Petersburg if speed matters more.

Upscale

• Tokyo: use when you want a natural upscale without exaggeration. It focuses on preserving the original look and fine structures instead of “inventing” new details, making it ideal when realism and faithfulness matter more than sharpness.
• Kyoto: use for real-world photos (people, landscapes, products). It excels at restoring details while handling noise, blur, and compression artifacts. Ideal for practical applications where images are imperfect, and you want visually pleasing, robust results fast.
• Saitama: use for cartoon, drawings, line art, and digital illustrations. It preserves clean lines, flat colors, and stylized shading without introducing photo-like textures. Best when sharp edges and stylistic consistency matter more than realism.
• Osaka: use when you want the best possible quality upscale available. It rebuilds detail rather than just sharpening it, going furthest on photos that are soft or heavily compressed. It’s slow, though, and needs a powerful GPU to run well.

Verdict: start with Tokyo if you have a powerful GPU, then try Kyoto if it’s taking too long. Reach for Osaka only when the others leave the image looking soft, and you can afford the wait.

💣 Troubleshooting

“App Is Damaged/Blocked…” (Windows & macOS only)

For a couple of years now, Microsoft and Apple have required developers to join their “Developer Program” to gain the pretentious status of an identified developer 😛.

Translating to non-BS language, this means that if you’re not registered with them (i.e., paying the fee), you can’t freely distribute Windows or macOS software. Apps from unidentified developers will display a message saying the app is damaged or blocked and can’t be opened.

To bypass this, open the Terminal and run one of the commands below (depending on your operating system), replacing <path-to-app> with the correct path to where you’ve installed the app:

• Windows: Unblock-File -Path <path-to-app>
• macOS: xattr -d com.apple.quarantine <path-to-app>

“Trojan:XXXXXX” detected (Windows only)

This is a false positive. It isn’t a specific virus, but a generic label Windows Defender uses when something behaves suspiciously. The installer downloads the app, unpacks it, creates a Start Menu shortcut and adds it to your PATH; normal installer steps that, combined in a small unsigned script, match a pattern Defender is cautious about.

I suggest to upload the app binary to VirusTotal and you’ll get a clean report. You can also read the source or build the binary yourself, but if you’re still uneasy, don’t disable your antivirus; just wait until the detection clears.

The app is taking too long to download dependencies

This app has some important dependencies that can’t be bundled with the app itself because they are rather big, like ONNX Runtime, CUDA and TensorRT (if supported by your system). They are hosted on Github and the app will download them the first time it opens.

Unfortunately, GitHub has a rate limit that will throttle the download speed if these files are downloaded too frequently. Since this is an open-source and free project I can’t afford to pay for a hosted solution where we wouldn’t have this problem.

If someday this project receives enough funds/donations, then I will pay for a better hosting solution. Meanwhile, bare with me on this one.

The model is taking too long to load (TensorRT only)

When you open the app for the first time, if it detects that TensorRT is available on your system, it will prompt you to enable it or not. If you choose to enable it, all models will run with TensorRT acceleration.

This is one of the fastest ways to run the models; however, TensorRT needs to optimize the model graphs the first time it’s used, which can take a few minutes. This is why it seems to be taking too long or even stuck when you run the models for the first time. But on subsequent runs, when the TensorRT optimization is already done, all enhancements will run much faster.

If you don’t want to use TensorRT acceleration, you can disable it in the app Settings.

🐛 Error Reporting

If you encounter any issues while using the app, please report them by creating a new issue on our repository and give as much detail as possible, including steps to reproduce the issue, screenshots, and any error messages you receive.

Errors reported by e-mail or other channels will not be tracked, so please make sure to report them on Github.

🛠️ Build

Dependencies

To build this project, you will need the following dependencies installed in your computer:

• Rust
• Just

If you want to build the GUI you will also need:

• Node.js
• PNPM

Compiling

With all the dependencies installed, in the project’s root folder run the command:

just build <interface> <architecture>

Where:

• <interface>: can be cli or gui.
• <architecture>: can be x64 or arm64 (optional).

For example, if I wanted to build a GUI version of the app, on architecture x64, I would run the command:

just build gui x64

❤️ Sponsors

This project is possible due to the generous contributions from my sponsors. You can see the full list of sponsors on my GitHub profile.

If you find Open Photo AI useful, please consider becoming a sponsor too.

📝 License

Open Photo AI is released under the AGPL-3.0 License. See LICENSE for details.

👨🏾‍💻 Author

Vinicius Egidio (vinicius.io)