Intel® Open Image Denoise

This is release v2.5.0 of Intel Open Image Denoise. For changes and new features see the changelog. Visit https://www.openimagedenoise.org for more information.

Overview

Intel Open Image Denoise is an open source library of high-performance, high-quality denoising filters for images rendered with ray tracing. Intel Open Image Denoise is part of the Intel® Rendering Toolkit and is released under the permissive Apache 2.0 license. It has been recognized with a Technical Achievement Award by the Academy of Motion Picture Arts and Sciences in 2025 for its contribution to the motion picture industry.

The purpose of Intel Open Image Denoise is to provide an open, high-quality, efficient, and easy-to-use denoising library that allows one to significantly reduce rendering times in ray tracing based rendering applications. It filters out the Monte Carlo noise inherent to stochastic ray tracing methods like path tracing, reducing the amount of necessary samples per pixel by even multiple orders of magnitude (depending on the desired closeness to the ground truth). A simple but flexible C/C++ API ensures that the library can be easily integrated into most existing or new rendering solutions.

At the heart of the Intel Open Image Denoise library is a collection of efficient deep learning based denoising filters, which were trained to handle a wide range of samples per pixel (spp), from 1 spp to almost fully converged. Thus it is suitable for both preview and final-frame rendering. The filters can denoise images either using only the noisy color (beauty) buffer, or, to preserve as much detail as possible, can optionally utilize auxiliary feature buffers as well (e.g. albedo, normal). Such buffers are supported by most renderers as arbitrary output variables (AOVs) or can be usually implemented with little effort.

Although the library ships with a set of pre-trained filter models, it is not mandatory to use these. To optimize a filter for a specific renderer, sample count, content type, scene, etc., it is possible to train the model using the included training toolkit and user-provided image datasets.

Intel Open Image Denoise supports a wide variety of CPUs and GPUs from different vendors:

• Intel® 64 architecture compatible CPUs (with at least SSE4.1)

• ARM64 (AArch64) architecture CPUs (e.g. Apple silicon CPUs)

• Intel Xe, Xe2, and Xe3 architecture dedicated and integrated GPUs, including Intel® Arc™ B-Series Graphics, Intel® Arc™ A-Series Graphics, Intel® Arc™ Pro Series Graphics, Intel® Data Center GPU Flex Series, Intel® Data Center GPU Max Series, Intel® Iris® Xe Graphics, Intel® Core™ Ultra Processors with Intel® Arc™ Graphics, 11th-14th Gen Intel® Core™ processor graphics, and related Intel Pentium® and Celeron® processors (Xe-LP, Xe-LPG, Xe-LPG+, Xe-HPG, Xe-HPC, Xe2-LPG, Xe2-HPG, Xe3-LPG, and Xe3p-XPC microarchitectures)

• NVIDIA GPUs with Turing, Ampere, Ada Lovelace, Hopper, and Blackwell architectures

• AMD GPUs with RDNA 2, RDNA 3, RDNA 3.5, and RDNA 4 architectures

• Apple silicon GPUs (M1 and newer)

It runs on most machines ranging from laptops to workstations and compute nodes in HPC systems. It is efficient enough to be suitable not only for offline rendering, but, depending on the hardware used, also for interactive or even real-time ray tracing.

Intel Open Image Denoise exploits modern instruction sets like SSE4, AVX2, AVX-512, Intel® Advanced Matrix Extensions (Intel® AMX), and NEON on CPUs, Intel® Xe Matrix Extensions (Intel® XMX) on Intel GPUs, and various other AI acceleration capabilities on NVIDIA, AMD, and Apple GPUs.

System Requirements

You need an Intel® 64 (with SSE4.1) or ARM64 architecture compatible CPU to run Intel Open Image Denoise, and you need a 64-bit Windows, Linux, or macOS operating system as well.

For Intel GPU support, please also install the latest Intel graphics drivers:

• Windows: Intel® Graphics Driver 31.0.101.4953 or newer

• Linux: Intel® software for General Purpose GPU capabilities release 20230323 or newer

Using older driver versions is not supported and Intel Open Image Denoise might run with only limited capabilities, have suboptimal performance or might be unstable. Also, Resizable BAR must be enabled in the BIOS for Intel dedicated GPUs if running on Linux, and strongly recommended if running on Windows.

For NVIDIA GPU support, please also install the latest NVIDIA graphics drivers:

• Windows: Version 528.33 or newer

• Linux: Version 525.60.13 or newer

For AMD GPU support, please also install the latest AMD graphics drivers:

• Windows: AMD Software: Adrenalin Edition 25.30.02.01 or newer

• Linux: Radeon Software for Linux version 25.30.1 or newer

For Apple GPU support, macOS Ventura or newer is required.

Support and Contact

Intel Open Image Denoise is under active development, and though we do our best to guarantee stable release versions a certain number of bugs, as-yet-missing features, inconsistencies, or any other issues are still possible. Should you find any such issues please report them immediately via the Intel Open Image Denoise GitHub Issue Tracker (or, if you should happen to have a fix for it, you can also send us a pull request); for missing features please contact us via email at openimagedenoise@googlegroups.com.

Join our mailing list to receive release announcements and major news regarding Intel Open Image Denoise.

Citation

If you use Intel Open Image Denoise in a research publication, please cite the project using the following BibTeX entry:

@misc{OpenImageDenoise,
  author = {Attila T. {\'A}fra},
  title  = {{Intel\textsuperscript{\textregistered} Open Image Denoise}},
  year   = {2026},
  note   = {\url{https://www.openimagedenoise.org}}
}

Compilation

The latest Intel Open Image Denoise sources are always available at the Intel Open Image Denoise GitHub repository. The default master branch should always point to the latest tested bugfix release.

Prerequisites

You can clone the latest Intel Open Image Denoise sources using Git with the Git Large File Storage (LFS) extension installed:

git clone --recursive https://github.com/OpenImageDenoise/oidn.git

Please note that installing the Git LFS extension is required to correctly clone the repository. Cloning without Git LFS will seemingly succeed but actually some of the files will be invalid and thus compilation will fail.

Intel Open Image Denoise currently supports 64-bit Linux, Windows, and macOS operating systems. Before you can build Intel Open Image Denoise you need the following basic prerequisites:

• CMake 3.15 or newer

• A C++11 compiler (we recommend using a Clang-based compiler but also support GCC and Microsoft Visual Studio 2015 and newer)

• Python 3

To build support for different types of CPUs and GPUs, the following additional prerequisites are needed:

CPU device:

• Intel® SPMD Program Compiler (ISPC) 1.30.0 or newer. Please obtain a release of ISPC from the ISPC downloads page. The build system looks for ISPC in the PATH and in the directory right “next to” the checked-out Intel Open Image Denoise sources. For example, if Intel Open Image Denoise is in ~/Projects/oidn, ISPC will also be searched in ~/Projects/ispc-v1.30.0-linux. Alternatively set the CMake variable ISPC_EXECUTABLE to the location of the ISPC compiler.

• Intel® Threading Building Blocks (TBB) 2017 or newer

SYCL device for Intel GPUs:

• oneAPI DPC++ Compiler, one of the following versions (other versions might work as well but have not been validated with Intel Open Image Denoise):

  • oneAPI DPC++ Compiler 6.1.0. This is the open source version of the compiler. Versions 6.2.x and 6.3.0 may cause crashes or device detection failures on Windows so it is highly recommended to avoid these.
  • Intel® oneAPI DPC++/C++ Compiler 2025.3 or newer

• Optional: Intel® Graphics Offline Compiler for OpenCL™ Code (OCLOC), if building with OIDN_DEVICE_SYCL_AOT enabled

  • Windows: Version 2025.3.3 / 32.0.101.8331 or newer as a standalone component of Intel® oneAPI Toolkits, which must be extracted and its contents added to the PATH. Also included with Intel® oneAPI Base Toolkit.

  • Linux: Included with Intel® software for General Purpose GPU capabilities release LTS 2523.x or newer (install at least intel-opencl-icd on Ubuntu, intel-ocloc on RHEL or SLES). For more recent versions please refer to Intel® Graphics Compute Runtime for oneAPI Level Zero and OpenCL™ Driver.

• If using Intel® oneAPI DPC++/C++ Compiler: CMake 3.25.2 or newer

• Ninja or Make as the CMake generator. The Visual Studio generator is not supported.

CUDA device for NVIDIA GPUs:

• CMake 3.18 or newer

• NVIDIA CUDA Toolkit 12.8 or newer

HIP device for AMD GPUs:

• CMake 3.21 or newer

• Ninja or Make as the CMake generator. The Visual Studio generator is not supported.

• AMD ROCm (HIP SDK) v6.4.2 or newer.

Metal device for Apple GPUs:

• CMake 3.21 or newer

• Xcode 15.0 or newer

Depending on your operating system, you can install some required dependencies (e.g., TBB) using yum or apt-get on Linux, Homebrew or MacPorts on macOS, and vcpkg on Windows. For the other dependencies please download the necessary packages or installers and follow the included instructions.

Compiling on Linux/macOS

If you are building with SYCL support on Linux, make sure that the DPC++ compiler is properly set up. The open source oneAPI DPC++ Compiler can be downloaded and simply extracted. However, before using the compiler, the environment must be set up as described in the Get Started Guide.

Alternatively, if you have installed Intel® oneAPI DPC++/C++ Compiler instead, you can set up the compiler by sourcing the vars.sh script in the env directory of the compiler install directory, for example,

source /opt/intel/oneAPI/compiler/latest/env/vars.sh

This script will put the icx and icpx compiler executables from the Intel(R) oneAPI DPC++/C++ Compiler in your PATH.

• Create a build directory, and go into it using a command prompt

  mkdir oidn/build
  cd oidn/build
  

  (We do recommend having separate build directories for different configurations such as release, debug, etc.).

• CMake will use the default compiler, which on most Linux machines is gcc, but it can be switched to clang by executing the following:

  cmake -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ..
  

  If you are building with SYCL support, you must set the DPC++ compiler (clang/clang++ or icx/icpx) as the C/C++ compiler here. Note that the compiler variables cannot be changed after the first cmake or ccmake run.

• Open the CMake configuration dialog

  ccmake ..
  

• Make sure to properly set the build mode and enable the components and options you need. By default only CPU support is built, so SYCL and other device support must be enabled manually (e.g. with the OIDN_DEVICE_SYCL option). Then type ’c’onfigure and ’g’enerate. When back on the command prompt, build the library using

  ninja
  

Compiling on Windows

If you are building with SYCL support, make sure that the DPC++ compiler is properly set up. The open source oneAPI DPC++ Compiler can be downloaded and simply extracted. However, before using the compiler, the environment must be set up as described in the Get Started Guide.

Alternatively, if you have installed Intel® oneAPI DPC++/C++ Compiler instead, you can either open a regular “Command Prompt” and execute the vars.bat script in the env directory of the compiler install directory, f