State of the ART: AI denoising in ART on Linux

Key points

• AI denoising can produce more natural-looking results than traditional noise reduction, especially at high ISO—preserving fine detail rather than smoothing it away.
• Once set up, using it is as simple as right-clicking a raw file in ART and selecting “AI denoise” from the menu.
• The configuration generator on this page does a lot of the hard technical work for you. Just fill in a few details and download your personalised setup files.
• All the terminal commands you need are provided in these instructions. You can copy them and adjust them as needed.
• This guide uses the AppImage version of ART, which works reliably with external AI tools. The Flatpak version has sandbox restrictions that can block the integration entirely.
• Every non-obvious problem in this setup has already been solved here. You’re following a tested, working path.

Denoising in ART on Linux

Noise reduction is one of the most important steps in processing a raw photo. ART, a free open-source raw editor, can use AI to reduce noise in ways that compete with expensive commercial software. This guide walks you through setting it up on Linux.

Getting AI denoising to work in ART on Linux turned out to be a lot more involved than I expected. The official documentation covers the basics. But several problems only reveal themselves when you actually try to set it up: the wrong version of ART blocks access to the AI tools, a progress dialog may silently cancel the denoising before it finishes, and a display compatibility problem can prevent ART’s window from appearing at all.

I worked through all of these problems one by one. This guide documents what I found and how I fixed it, so you don’t have to spend the same time I did figuring it out.

Fair warning: this involves running terminal commands. Not a lot, but some. Each command is explained so you know what you’re doing and why. The whole process takes just a few minutes, aside from download times.

What is ART?

ART (A Raw Toolbox) is a free, open-source raw image editor for Linux, Windows and Mac. It’s well suited for professional use, with a clean and uncluttered interface. You can download it from artraweditor.github.io.

Is AI denoising actually better than what ART already does?

ART includes its own built-in noise reduction tool, and it’s a good one. So why go to the trouble of setting up an external AI denoiser? The answer comes down to the type of noise reduction each approach performs.

ART’s built-in noise reduction works by analysing the image mathematically to try to distinguish between noise and genuine detail. It’s fast, gives you direct control over the strength, and works entirely within your normal editing workflow. For moderate noise levels it does a good job.

AI-based denoisers like nind-denoise take a fundamentally different approach. Rather than applying mathematical rules, they’ve been trained on thousands of pairs of noisy and clean photographs of real-world subjects. The AI has effectively learned what a clean photograph looks like. It uses that knowledge to recover detail that traditional tools would smooth away or mistake for noise. The results, especially at high ISO, can look more natural, with less of the plastic or watercolour smoothing effect that traditional denoisers can produce when pushed hard.

For everyday shooting at moderate ISO, ART’s built-in noise reduction is capable and convenient. The AI workflow described in this guide is more valuable for challenging high-ISO images where you want to extract maximum detail and quality.

AppImage or Flatpak: which version of ART should you use?

ART is available for Linux in Flatpak and AppImage formats. For everyday use either works fine. But for AI denoising the AppImage works better. Here’s why.

The Flatpak sandbox problem

Flatpak apps run inside a security sandbox, a kind of walled garden that prevents the app from freely accessing the rest of your system. For a photo editor this is usually OK. But it becomes a problem when you want ART to run external AI tools, because the sandbox can block access to everything the denoiser needs. The only known workaround is complex and unreliable. And fiddling with workarounds (that might not work!) is a lot of effort just to run a denoiser.

The AppImage advantage

An AppImage is a self-contained file that runs with your normal user permissions and can freely access everything it needs on your system. The integration works exactly as the ART documentation describes. So that’s why I use the ART AppImage, and this guide focuses on it.

A complication depending on what kind of Linux you’re using

Most modern Linux desktops now use a display system called Wayland, replacing the older X11 system. X11 is still available as a fallback on some distros, but it’s increasingly considered legacy.

The ART AppImage has a minor compatibility issue with Wayland: its window may not appear unless you tell it to use a compatibility layer called XWayland. This guide covers that in step 3 (the configuration generator).

To find out which display system your Linux distro is using, open a terminal and run:

echo $XDG_SESSION_TYPE

If it prints “wayland” select Wayland in the configuration generator in Step 3. If it prints “x11” select X11 instead, the Wayland compatibility fix won’t be needed.

nind-denoise or RawForge?

ART supports two AI denoising tools: nind-denoise and RawForge. Both are free and open source. Here’s how they compare, and why this guide focuses on nind-denoise.

nind-denoise

nind-denoise was developed as academic research in 2019 and has been independently reviewed, tested, and used extensively since then. The results are natural-looking noise reduction that preserves detail well.

RawForge

RawForge is a newer tool with an interesting advantage: it works directly on your camera’s raw sensor data rather than a converted image. In theory this produces better results, because noise behaves more predictably at that stage. It also lets you control the strength of noise reduction separately for colour and brightness.

Why nind-denoise is the better choice right now

RawForge’s approach is promising. But as of May 2026 it’s an alpha release (early software that hasn’t been widely tested).

nind-denoise, on the other hand, has been in use since 2019, has research behind it, and is the tool the ART developer maintains and recommends. It’s more mature and better tested.

RawForge may have an advantage in theory. But whether it actually produces better results than nind-denoise still needs to be confirmed. For now, nind-denoise is the safer choice. RawForge is worth keeping an eye on as it matures.

At a glance

	nind-denoise	RawForge
Maturity	Established (2019)	Alpha: early, untested
Noise strength control	Fixed, model determines strength	Separate colour + brightness sliders
Output format	TIFF	DNG (see note below)
Denoising models	Multiple, on Google Drive	Bundled with package
ART integration	Mature, well-tested	Less tested
Community	Small but established	Essentially none yet
Active development	Maintenance mode	Active but early
Slight darkening artefact	Yes	Not yet established

Note: RawForge DNG files may show a missing colour matrix warning in some editors for certain camera models. This is a known issue with the alpha release and another reason to treat RawForge as a work in progress.

Installation instructions

What you’ll need before starting

• The ART AppImage downloaded from https://github.com/artraweditor/ART/releases.
• The nind neural network models. The neural network models are hosted on Google Drive. Visit this link and download the model files that interest you:
  https://drive.google.com/drive/folders/1XmY9yO3yhhhdwQ_btYCIpkUBFQ88H-pr
  You’ll extract them later into a specific folder.
• Python 3: a free programming language that the AI denoising tool is built on. You don’t need to know anything about it, just have it installed.

For Ubuntu/Debian-based Linux:

sudo apt install python3-venv python3-pip

For Arch-based Linux:

sudo pacman -S python

Other distros: refer to your distribution’s package manager documentation.

• Two additional utilities, “zenity” (shows progress dialogs) and “exiftool” (copies metadata from your original raw file to the denoised output). To install them, run this command from a terminal:

For Ubuntu/Debian-based Linux:

sudo apt install zenity exiftool

For Arch-based Linux:

sudo pacman -S zenity perl-image-exiftool

Other distros: the package names and install commands will vary. Refer to your distribution’s package manager documentation.

• A terminal (command line) application: you should be able to start one using one of these methods:
  Press “CTRL” + “ALT” + “T.”
  Press “ALT” + “F2.” Then, type “gnome_terminal”.
  Press the “Dash” or “Windows” key. Then, type “terminal”.
  Go to Settings > Hardware > Keyboard > Shortcuts to make your own shortcut.

• An internet connection for downloading tools.
• Optional: A CUDA-capable NVIDIA GPU—recommended for speed, but CPU works too (just slower).

Step 1 — Make sure you have all pre-requisites in place

If you haven’t already, do the following as described above:

1. Download the most recent ART .appimage.
2. Download the nind models.
3. Make sure Python 3 is installed.
4. Install the utilities zenity and exiftool.

Note: throughout these instructions, replace “{NAME OF YOUR DOWNLOADED ART APPIMAGE}” with the name of the ART .appimage you downloaded, for example “ART-1.26.4-x86_64” or “ART-1.26.4-aarch64”.

Step 2 — Put the AppImage somewhere permanent

Create a dedicated folder for your .appimage applications, and move the AppImage there. For example, I have my ART .appimage saved in /Home/Applications. These instructions assume that setup. If you prefer a different applications folder, edit the commands in these instructions accordingly.

mkdir -p ~/Applications/ART
mv ~/Downloads/{NAME OF YOUR DOWNLOADED ART APPIMAGE}.AppImage ~/Applications/ART/
chmod +x ~/Applications/ART/{NAME OF YOUR DOWNLOADED ART APPIMAGE}.AppImage

The chmod +x command marks it as executable so Linux will run it as a program.

Step 3 — Extract the AppImage

This is the most important and least obvious step. The AppImage contains both a visual interface and a background tool that scripts use to process your images. The only reliable way to use both is to extract the AppImage contents first:

cd ~/Applications/ART
./{NAME OF YOUR DOWNLOADED ART APPIMAGE}.AppImage --appimage-extract

This creates a folder called “squashfs-root” containing the actual program files. Verify that both ART and ART-cli are in it:

ls ~/Applications/ART/squashfs-root/

You should see both listed. The extraction only needs to be done once, but if you ever update to a newer AppImage version you’ll need to repeat this step.

Step 4 — Generate your configuration files

The form below generates the configuration files you’ll need, pre-filled with your personal details. Fill it in now and download the files. The steps below will tell you exactly where to put each one.

You’ll also need to choose a denoising model. The options are explained in Step 8.

Step 5 — Save the configuration files

Download the configuration files using the generator above. You can download them individually or as a single ZIP file; the ZIP is easier.

If you downloaded the ZIP file, extract it first:

python3 -c "import zipfile; zipfile.ZipFile('$(echo ~/Downloads/art-nind-config.zip)').extractall('$(echo ~/Downloads)')"

Now run these commands to create the necessary folders and move the files into the correct locations:

mkdir -p ~/.local/bin
mkdir -p ~/.config/ART/usercommands
mv ~/Downloads/ART-cli ~/.local/bin/
mv ~/Downloads/ART-gui ~/.local/bin/
mv ~/Downloads/nind_denoise.txt ~/.config/ART/usercommands/
mv ~/Downloads/nind_denoise_raw.sh ~/.config/ART/usercommands/

Then make the scripts executable so Linux will run them as programs:

chmod +x ~/.local/bin/ART-cli
chmod +x ~/.local/bin/ART-gui
chmod +x ~/.config/ART/usercommands/nind_denoise_raw.sh

What do these files do?

• ART-cli — the background tool that processes your images
• ART-gui — launches ART correctly on your display system
• nind_denoise.txt — adds the AI denoising option to ART’s right-click menu
• nind_denoise_raw.sh — a script that does all the work when you trigger the denoising

Optional: fix your desktop shortcut

If you have a .desktop shortcut for ART (for launching from your application menu), update its Exec line to use the new launcher. Open the .desktop file in a text editor and change:

Exec=/path/to/{NAME OF YOUR DOWNLOADED ART APPIMAGE}.AppImage %f

to:

Exec=/home/YOUR_USERNAME/.local/bin/ART-gui %f

Then run:

update-desktop-database ~/.local/share/applications/

Step 6 — Download nind-denoise

Download the version of nind-denoise maintained by the ART developer, which is optimised to work with ART:

cd ~/Applications/ART
git clone --depth 1 https://github.com/agriggio/nind-denoise

Step 7 — Set up a Python environment

You have already made sure that Python 3 is installed in step 1 (right?).

Step 7a — Create the Python environment

This creates an isolated workspace for the AI tools so they don’t interfere with anything else on your system:

cd ~/Applications/ART
python3 -m venv ART-AI-venv

Step 7b — Install the Python libraries

This installs the libraries that the denoising tool needs to run. The “.” at the start of the first command is required. It activates the Python environment in your current terminal session.

. ./ART-AI-venv/bin/activate
pip install torch torchvision ConfigArgParse opencv-python pyyaml piqa
deactivate

This may take a few minutes. Some of the libraries are large downloads.

Step 8 — Save the downloaded denoising models

First, make sure the correct denoising models folder exists (it might already be there, but better safe than sorry):

mkdir -p ~/Applications/ART/nind-denoise/models/nind_denoise/

Extract the model ZIP file(s) you downloaded earlier into ~/Applications/ART/nind-denoise/models/nind_denoise/.

Important! If after you unzip the ZIP file in that folder, you see a subfolder called “denoise_models”, you need to move the contents of that subfolder one level up so the contents are all in ~/Applications/ART/nind-denoise/models/nind_denoise/.

To see what models you have available at any time:

find ~/Applications/ART/nind-denoise/models -name "*.pth" -o -name "*.pt"

There are two types of denoising AI model: UNet (older) and UtNet (newer, recommended). You can tell them apart by the folder name: UtNet model folders contain the word “utnet”. The most recent UtNet model generally gives the best results.

Step 9 — Test from the terminal first

Before testing from ART, run the script directly from the terminal so you can see what’s happening:

bash ~/.config/ART/usercommands/nind_denoise_raw.sh /path/to/your/raw-file.RAW

You should see a progress counter like 0/176, 1/176 and so on, followed by:

Denoised image written to /tmp/tmp.XXXXXX/denoised.tif
Wrote denoised image to /tmp/tmp.XXXXXX/denoised.tif

The finished file will appear in the same folder as your original raw file, named FILENAME-denoised.tif.

The output file mentioned in the terminal (/tmp/tmp…/denoised.tif) is a temporary file used during processing. It will be automatically cleaned up so you don’t need to do anything about it. The finished file has already been saved to the same folder as your original raw file. When you’re ready, move on to Step 10 to test the full integration from within ART itself.

If something goes wrong, you’ll see an error message like this:

You can ignore any other error messages you may see in the terminal that appear before the counter.

Step 10 — Use it in ART

Launch ART from the command line:

ART-gui &

Navigate to a folder containing raw files using the File Browser tab in ART. Right-click on a raw file thumbnail. You should see AI denoise (nind-denoise) in the context menu. Click it.

A “Converting to TIFF” progress dialog will appear while ART processes your raw file. After that, the denoising runs. This may take a minute or two depending on your hardware, so be patient.

Note: the denoising progress dialog may not appear when running from ART under Wayland. The process is still running in the background. Just be patient and wait for the output file to appear.

Tips for getting the best results

Choose the right model. The newer UtNet models generally outperform the older UNet ones. If you downloaded multiple models, experiment to find which one you prefer for your camera and typical shooting conditions.

The denoised image may be slightly darker. This is a known characteristic of these AI models. To counteract this, apply a small exposure or brightness adjustment in ART when you open the denoised TIFF for final editing.

Denoise before sharpening. Sharpening adds artificial contrast at edges to make them look crisper. The denoiser sees that artificial contrast as noise and tries to remove it, taking the detail back out that sharpening just put in. You end up with a worse result than if you’d done neither. Always denoise first, then sharpen. The denoising script takes care of this: it automatically disables sharpening when preparing the image for denoising.

Known issues

• Zenity progress dialog missing: The denoising progress dialog may not appear when launching from ART under Wayland. Check for the output file after waiting about a minute.
• Harmless warning messages on launch: Some technical warning messages may appear every time ART starts. These are filtered out by the script and can be safely ignored.
• Exiftool metadata warning: A minor warning about “Fixed incorrect URI for xmlns:MicrosoftPhoto” may appear during processing. This is harmless. It just means that exiftool is automatically correcting a minor metadata issue and the output file is unaffected.
• Updating ART: If you download a newer version of ART, you’ll need to repeat the extraction step and update the version number in your configuration files.
• Slight image darkening: Covered above under tips — a small exposure adjustment in ART corrects this.

Key takeaways

• Use the AppImage version of ART, not the Flatpak. The Flatpak sandbox often blocks access to external AI tools.
• The AppImage must be extracted before it can be used reliably for AI denoising.
• On Wayland, ART needs a small compatibility fix to display its window correctly. The configuration files handle this for you.
• One configuration file needs to know the exact location of another file on your system. The setup scripts handle this for you automatically.
• Install the AI libraries in an isolated Python environment so they don’t conflict with anything else on your system.
• Choose a UtNet model over the older UNet models for best results.
• The denoised image may be slightly darker than the original. Correct this with a small exposure adjustment in ART.
• Don’t sharpen before denoising.
• If the zenity progress dialog doesn’t appear, don’t worry. The denoising is still running in the background.