Physically based unidirectional (backwards) Monte Carlo path tracer written with the HIPRT and Orochi libraries.

HIPRT is AMD's equivalent to OptiX. It allows the use of the ray tracing accelerators of RDNA2+ AMD GPUs and can run on NVIDIA devices as well (although it wouldn't take advatange of RT cores) as it is not AMD specific.

The Orochi library allows the loading of HIP and CUDA libraries at runtime meaning that the application doesn't have to be recompiled to be used on a GPU from a different vendor (unlike HIP alone which, despite being compatible with NVIDIA and AMD hardware, would require a recompilation).

• AMD RDNA1 GPU or newer (RX 5000 or newer) or NVIDIA Maxwell GPU or newer (GTX 700 & GTX 900 Series or newer)
• Visual Studio 2022 (only version tested but older versions might work as well) on Windows
• CMake
• CUDA for NVIDIA compilation

• Coat Microfacet GGX Layer + Anisotropy, Anisotropy Rotation, Medium Absorption & Thickness
• SGGX Volumetric Sheen Lobe LTC Fit [Zeltner, Burley, Chiang, 2022]
• Specular Microfacet GGX Layer
• Diffuse BRDF lobe. Support for:
  • Lambertian
  • Oren-Nayar
• Metallic Microfacet GGX Layer + Anisotropy & Anisotropy Rotation + Double Roughness [Kulla & Conty, 2017]
• MRRM retro-reflection conductor layer [Portsmouth et al., 2026]
• Specular transmission BTDF + Beer Lambert Volumetric Absorption [Burley, 2015]
• Diffuse Lambertian BTDF
• Spectral dispersion using Cauchy's equation
• Microfacet BRDFs multiple-scattering:
  • Multiple-bounce Smith Microfacet BRDFs using the Invariance Principle [Cui et al., 2023]
  • Energy compensation for conductors (double metal layer), dielectrics (transmission layer), glossy-diffuse (specular + diffuse layer) and coated (coat layer) materials [Turquin, 2019]
• Thin-film interference over dielectrics and conductors [Belcour, Barla, 2017]
• Thin-walled model

• Light sampling techniques:

  • Uniform light sampling for direct lighting estimation
  • Power-proportional light sampling
  • Light hierarchies:
    • Importance Sampling of Many Lights with Adaptive Tree Splitting [Conty et al., 2018]
      • SAH and SAOH tree build cost functions
      • Adaptive tree splitting, shading multiple light samples per shading point
    • Hierarchical Light Sampling with Accurate Spherical Gaussian Lighting [Tokuyoshi et al., 2024]
      • Improved rejection of backfacing lights with -style orientation cone
      • Support for multiple spherical gaussian spatial lobes per tree node to improve importance estimates on multi-modal incoming radiance
  • ReGIR (more details on what was implemented below)
    • Disney's cache points Disney's Cache Points [Li et al., 2024] (partial implementation for ReGIR)
  • Learning to Cluster for Many Lights Rendering [Wang et al., 2021], piggybacking on an implementation of the illumination-aware KD-tree of [Zheng et al., 2026] and the spherical gaussian light tree [Tokuyoshi et al., 2024]
  • Neural Importance Sampling of Many Lights [Figuereido et al., 2025]

• Area light sampling strategies:

  • Uniform area sampling
  • Solid angle sampling [Peters, 2021]
  • Projected solid angle [Peters, 2021]
  • BSDF * (projected) solid angle product sampling with LTCs [Heitz et al., 2016], [Peters, 2021]

• NEE estimators (built on-top of base techniques):

  • Naive NEE (light sampling only)
  • NEE with MIS (BSDF sampling + light sampling)
  • ReGIR [Boksansky et al., 2021] for many-lights sampling augmented with:
    • Representative cell surface-data + integration with NEE++ for resampling according to the product BRDF * L_i * G * V
    • Partial implementation of Disney's Cache Points [Li et al., 2024] with per-cell light distributions
    • Spatial reuse
    • Per-cell RIS integral normalization factor pre-integration for multiple importance sampling support
    • Hash grid
    • The implementation and logic is detailed in my ReGIR blog post.
  • RIS (Resampled Importance Sampling) [Talbot et al., 2005]with Weighted Reservoir Sampling (WRS) [M. T. Chao, 1982]
  • RISLTC [Shash et al., 2023]
  • ReSTIR DI [Bitterli et al., 2020] (removed at commit "Remove ReSTIR DI support", tag remove-restir-di-support)

• Other light sampling features

  • Next Event Estimation++ [Guo et al., 2020] + Custom envmap support
  • NEE for HDR environment maps using:
    • Alias Table (Vose's O(N) construction [Vose, 1991])
    • CDF-inversion & binary search

• BSDF sampling:

  • GGX NDF Sampling:
    • Visible Normal Distribution Function (VNDF) [Heitz, 2018]
    • Spherical caps VNDF Sampling [Dupuy, Benyoub, 2023]

• Path sampling:

  • BSDF Sampling:
    • One sample MIS for lobe sampling [Hery et al., 2017]
  • ReSTIR GI [Ouyang et al., 2021]
  • ReSTIR Path Guiding [Zeng at al., 2025]

• ReSTIR Samplers:

  • ReSTIR DI [Bitterli et al., 2020] (removed at commit "Remove ReSTIR DI support", tag remove-restir-di-support)
    • Supports envmap sampling
  • ReSTIR GI [Ouyang et al., 2021]
  • ReSTIR PT [Lin et al., 2022]
    • ReSTIR PT Enhanced fused single reservoir DI-GI [Lin et al. 2026]
  • ReSTIR Path Guiding [Zeng at al., 2025]
  • Many MIS weighting schemes for experimentation:
    • 1/M
    • 1/Z
    • MIS-like,
    • Generalized balance heuristic [Lin et al., 2022]
    • Pairwise MIS [Bitterli, 2022] & defensive formulation [Lin et al., 2022])
    • Pairwise symmetric & asymmetric ratio MIS weights [Pan et al., 2024]
    • Stochastic pairwise MIS [Hedstrom et al., 2026]
  • Adaptive-directional spatial reuse for improved offline rendering efficiency
  • Compatibility-guided neighbor selection [Junkins et al., 2026]
  • Optimal visibility sampling [Pan et al., 2024]

• Distributing Monte Carlo Errors as a Blue Noise in Screen Space by Permuting Pixel Seeds Between Frames [Heitz and Belcour, 2019.]
• Microfacet Model Regularization for Robust Light Transport [Jendersie et al., 2019]
• G-MoN - Adaptive median of means for unbiased firefly removal [Buisine et al., 2021]
• Global Adaptive Sampling Hierarchies [Jeffery 2019]
• Per-pixel variance based adaptive sampling
• Texture alpha transparency support
• Stochastic material opacity support
• Normal mapping
• Nested dielectrics support
  • Handling with priorities as proposed in [Simple Nested Dielectrics in Ray Traced Images, Schmidt, 2002]
• A Low-Distortion Map Between Triangle and Square [Heitz, 2019]
• Intel Open Image Denoise + Normals & Albedo AOV support

• Interactive ImGui interface
  • Asynchronous interface to guarantee smooth UI interactions even with heavy path tracing kernels
• Interactive first-person camera
• Different frame-buffer visualization (visualize the adaptive sampling heatmap, converged pixels, the denoiser normals / albedo, ...)

• Use of the [ASSIMP] library to support many scene file formats.
• Multithreaded scene parsing/texture loading/shader compiling/BVH building/envmap processing/... for faster application startup times
• Background-asynchronous path tracing kernels pre-compilation
• Shader cache to avoid recompiling kernels unnecessarily

1. Install the HIP SDK (the renderer only runs with HIP SDK 7.1.1+ as of writing this)

2. Follow the "Compiling" steps.

To build the project on NVIDIA hardware, you will need to install the NVIDIA CUDA SDK v12.2 (minimum). It can be downloaded and installed from here.

Your CUDA_PATH environment variable then needs to be defined. This should automatically be the case after installing the CUDA Toolkit but just in case, you can define it yourself such that CUDA_PATH/include/cuda.h is a valid file path.

1. Install OpenGL, GLFW and glew dependencies:

sudo apt install freeglut3-dev
sudo apt install libglfw3-dev
sudo apt install libglew-dev

2. Install AMD HIP (if you already have ROCm installed, you should have a /opt/rocm folder on your system and you can skip this step):

Download amdgpu-install package: https://rocm.docs.amd.com/projects/install-on-linux/en/latest/install/amdgpu-install.html

Install the package:

sudo apt install ./amdgpu-install_xxxx.deb

Install HIP:

sudo amdgpu-install --usecase=hip

3. Normally, you would have to run the path tracer as sudo to be able to acces GPGPU compute capabilities. However, you can save yourself the trouble by adding the user to the render group and rebooting your system :

sudo usermod -a -G render $LOGNAME

1. Install OpenGL, GLFW and glew dependencies:

sudo apt install freeglut3-dev
sudo apt install libglfw3-dev
sudo apt install libglew-dev
sudo apt install libomp-dev

2. Install the NVIDIA CUDA SDK (called "CUDA Toolkit"). It can be downloaded and installed from here.

With the pre-requisites fulfilled, you now just have to run the CMake:

git clone https://github.com/TomClabault/HIPRT-Path-Tracer.git --recursive
cd HIPRT-Path-Tracer
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Debug ..

On Windows, a Visual Studio solution will be generated in the build folder that you can open and compile the project with (select HIPRTPathTracer as startup project).

On Linux, the HIPRTPathTracer executable will be generated in the build folder.

./HIPRT-Path-Tracer

The following arguments are available:

• <scene file path> an argument of the commandline without prefix will be considered as the scene file. File formats supported.
• --sky=<path> for the equirectangular skysphere used during rendering (HDR or not)
• --samples=N for the number of samples to trace*
• --bounces=N for the maximum number of bounces in the scene*
• --w=N / --width=N for the width of the rendering*
• --h=N / --height=N for the height of the rendering*

* CPU only commandline arguments. These parameters are controlled through the UI when running on the GPU.

Sources of the scenes can be found here.

GNU General Public License v3.0 or later

See COPYING to see the full text.