In this blog post we are announcing the open-source availability of the Radeon™ ProRender renderer, an implementation of the Radeon ProRender API. We will give a brief summary of its features and provide some technical insights into the internals of the renderer.

This initiative was started as a sample application demonstrating the usage of the AMD Radeon Rays intersection engine. It then evolved into a fully functional rendering engine aimed at graphics researchers, educational institutions and open-source enthusiasts in general. It is also an example aimed for developers to test integrating Radeon ProRender into their own applications.

Radeon ProRender is a fast and efficient GPU-based global illumination renderer implemented using OpenCL™ and relying on AMD’s Radeon Rays intersection engine. It is cross-platform and vendor independent. The only requirement it imposes on the hardware is OpenCL 1.2 support. Radeon ProRender maintains a high level of performance across all vendors, but is specifically optimized for AMD GPUs and APUs.


Please note the Radeon ProRender plugins have some features which are not currently available in the open source Radeon ProRender package. However, Radeon ProRender has a robust set of features such as:

Light transport

“Science Fiction” scene is a courtesy of Juan Carlos Silva,

Radeon ProRender is essentially a biased path-tracer, however it is highly configurable and can therefore be setup to run ray-tracing (sampling multiple light sources at once) instead of pure path tracing. An implementation of a bidirectional path tracing solver is being developed.


“City of the future 4” scene, provided by

To maintain high efficiency Radeon ProRender only supports triangle meshes and instances. However, quads can be used while working with Radeon ProRender via the Radeon ProRender API. This is possible because the API layer is capable of pre-tessellating quads and passing triangle meshes down to Radeon ProRender. The size of triangle meshes is only limited by available GPU memory. Instancing can be used to greatly reduce memory footprint by reusing geometric data and acceleration structures.

Internally meshes and instances are represented using the Shape interface. If used through Radeon ProRender API meshes and instances are represented by the rpr_shape opaque pointer type.


“Material orb” scene, courtesy of Silicon Studios

Radeon ProRender supports compound materials assembled from the following building blocks:

  • Matte BRDF (Lambertian)
  • Microfacet BRDF (GGX or Beckmann distributions)
  • Ideal reflection BRDF
  • Ideal refraction BTDF
  • Microfacet refraction BTDF (GGX or Beckmann distributions)
  • Transparent BTDF
  • Translucent BTDF
  • Emission

Each of these building blocks can have:

  • Built-in Fresnel factor
  • Normal map
  • Bump map

Building blocks are combined together using one of the following blend modes:

  • Mix – linear interpolation of components using fixed weight
  • Fresnel blend – linear interpolation of components with weight depending on angle of incidence

Materials can use RGBA uint8, float16 or float32 uncompressed textures for albedos, weights and normal/bump maps.

Internally materials are represented as a subclass of the Material class: SingleBxdf for individual components and MultiBxdf for compound materials. At the Radeon ProRender API level they are represented by the rpr_material_node opaque pointer. Note that not all Radeon ProRender materials are currently supported by Radeon ProRender open-source (see below section).


BMW Blender Benchmark model, courtesy of Mike Pan

Radeon ProRender supports the following types of lights:

  • Point light
  • Directional light
  • Spot light
  • Area light (emissive geometry)
  • Image-based environment light

All lights are internally represented by different subclasses of the Light interface. If being used via the RPR API, lights are represented by the rpr_light opaque pointer.


“Crytek Sponza” scene, courtesy of Frank Meinl, Crytek

Radeon ProRender can use one of the following samplers for random points/directions generation:

  • Random sampler (less efficient, mainly for debugging)
  • Sobol quasi- Monte-Carlo sampler
  • Correlated multi-jittered sampler

In addition, Radeon ProRender is using multiple importance sampling to reduce variance for both direct and indirect illumination. It also applies Russian roulette to terminate low-probability paths.

GPU execution model

Radeon ProRender is based on a split-kernel architecture to avoid Vector General Purpose Register (VGPR) occupancy bottlenecks and broadly uses GPU-optimized parallel primitives to restructure the work to better fit a massively parallel GPU architecture. First, the renderer is designed for progressive preview and has a synchronous nature. Meaning it has a Render() function which is getting called by the user in the loop and every call to this function adds a single sample to each pixel refining the image. This model allows to keep latency under control and manipulate the scene and the camera while rendering. Inside the Render() function each OpenCL work item is assigned a single pixel. As iterations (bounces) progress, fewer rays remain alive, so the Render() function compacts  the work to minimize GPU thread divergence.

Each call to Render() results in the following sequence of kernel calls:

  1. Spawn primary rays into ray buffer
  2. Trace ray buffer
  3. Apply potential volumetric scattering events (some ray misses might become hits here)
  4. Compact sparse hits buffer
  5. Evaluate volume material
  6. Evaluate surface material and generate light samples and shadow rays
  7. Trace shadow rays and add contributing light samples
  8. Sample surface and generate extension rays into rays buffer
  9. Go to step 2 (if bounce limits are not reached)


In terms of latency the renderer is capable of maintaining high FPS while doing progressive rendering for moderately sized scenes. For example on the following “Science Fiction” scene (775K triangles) Radeon ProRender produces 15 FPS in full HD resolution on a Radeon R9 Nano graphics card.

In terms of intersection throughput performance is determined by the underlying Radeon Rays engine. Below are several examples using the “Science Fiction” scene on a Radeon R9 Fury X graphics card:

Primary rays: 773 Mrays/s (2.68ms)

Secondary rays: 285 Mrays/s (7.27ms)

Shadow rays: 1109 Mrays/s (1.87ms)

Primary rays: 470 Mrays/s (4.42ms)

Secondary rays: 195 Mrays/s (10.66ms)

Shadow rays: 800 Mrays/s (2.59ms)

Primary rays: 562 Mrays/s (3.69ms)

Secondary rays: 270 Mrays/s (7.67ms)

Shadow rays: 1219 Mrays/s (1.7ms)

Radeon Pro Render API support

We provide an implementation of the Radeon ProRender API with Radeon ProRender open-source. The implementation is still in an early state of development so many features available in the internal RadeonTM ProRender core are not available in the open-source back end. The list of unsupported features follow:

  • Full material system (currently only basic BRDFs and blends of them are supported, no procedurals and arithmetic nodes)
  • Volumetrics (currently work in progress in Radeon ProRender)
  • IES lights
  • Visibility flags
  • Displacement and subdivision
  • Tilt shift camera
  • Bokeh shape controls
  • Multiple UVs
  • Post-processing
  • Analytic sky system


In this blogpost we have introduced a new open-source physically renderer and an open-source implementation of the Radeon ProRender API based on it. The renderer is fully open-source, cross-platform and demonstrates good performance across a whole range of hardware.

GitHub repo

Banner image created by The Pixelary using Radeon ProRender for Blender.