Open Photo AI is an open source alternative to the popular photo AI editor.
It currently supports the following enhancements:
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.
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:
curl -fsSL https://vegidio.github.io/open-photo-ai/install.sh | shirm https://vegidio.github.io/open-photo-ai/install.ps1 | iexThere 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 🎥)
- Click on the button
Browse imagesto select one or more images that you would like to enhance. - The images are enhanced automatically or manually depending on the toggle
Autopilotin 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.
- Select one or more images that you would like to export on the image drawer at the bottom of the screen.
- Click on the button
Export image, select the location and image format, then click onExport.
Coming soon...
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:
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
These are the features I plan to implement in the future, in no particular order:
- Model selection and enhancement customization.
- Support different preview layouts.
- Add a new model for light adjustment.
- Add app preferences so you don't have to configure them every time.
- Enable TensorRT acceleration when pre-warm-up is implemented.
- Simplify the app installation using packages and installers.
- Add a new model for color balance.
- Add new models for denoise, sharpening.
- Crop and rotate images in the GUI.
- Attempt to include diffusion-based models (this will be hard!)
- Internationalization to other languages.
- Add new models to colorize black and white photos.
- Rework the architecture of some models to improve performance.
- Add a new model to fix imperfections and remove objects from photos.
- CLI implementation.
- Improve documentation for the library.
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>
To run the GUI version of the app on Linux, you will need to install the following dependencies: libgtk and libwebkitgtk. To do that, open your terminal and run the following command, depending on your distribution:
- Debian/Ubuntu:
sudo apt install libgtk-4-1 libwebkitgtk-6.0-4 - Fedora 40+:
sudo dnf install gtk4 webkitgtk6.0 - Arch Linux:
sudo pacman -S gtk4 webkitgtk-6.0 - openSUSE:
sudo zypper install libgtk-4-1 libwebkitgtk-6_0-4
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.
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.
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.
To build this project, you will need the following dependencies installed in your computer:
If you want to build the GUI you will also need:
With all the dependencies installed, in the project's root folder run the command:
task <interface> arch=<architecture>Where:
<interface>: can becliorgui.<architecture>: can beamd64orarm64.
For example, if I wanted to build a GUI version of the app, on architecture AMD64, I would run the command:
task gui arch=amd64Open Photo AI is released under the AGPL-3.0 License. See LICENSE for details.
Vinicius Egidio (vinicius.io)