Download Precompiled OSPRay Binary Packages


Your CPU must support at least SSE4.1 or NEON to run OSPRay. The TGZ/ZIP packages contain most needed 3rd party dependencies. Additionally you need

We recommend the latest version of both TBB and Embree libraries.

GPU Runtime Requirements

To run OSPRay on Intel GPUs you will need to first have drivers installed on your system.

GPU drivers on Linux

Install the latest GPGPU drivers for your Intel GPU from: Follow the driver installation instructions for your graphics card.

GPU drivers on Windows

Install the latest GPGPU drivers for your Intel GPU from: Follow the driver installation instructions for your graphics card.


Packages for x86_64 are provided, OSPRay can be built for ARM64/NEON using the superbuild (see Building and Finding OSPRay).

For Linux we provide OSPRay precompiled for 64 bit (including the GPU module) as a TGZ archive.

For Mac OS X we provide OSPRay as a ZIP archives for x86_64 and ARM64 architectures:

For Windows we provide OSPRay binaries precompiled for 64 bit (including the GPU module) as an MSI installer as well as a ZIP archive.

The source code of the latest OSPRay version can be downloaded here:

You can also access previous OSPRay releases.

Building and Finding OSPRay

The latest OSPRay sources are always available at the OSPRay GitHub repository. The default master branch should always point to the latest bugfix release.


OSPRay currently supports Linux, Mac OS X, and Windows. In addition, before you can build OSPRay you need the following prerequisites:

Depending on your Linux distribution you can install these dependencies using yum or apt-get. Some of these packages might already be installed or might have slightly different names.

Type the following to install the dependencies using yum:

sudo yum install cmake.x86_64
sudo yum install tbb.x86_64 tbb-devel.x86_64

Type the following to install the dependencies using apt-get:

sudo apt-get install cmake-curses-gui
sudo apt-get install libtbb-dev

Under Mac OS X these dependencies can be installed using MacPorts:

sudo port install cmake tbb

Under Windows please directly use the appropriate installers for CMake, TBB, ISPC (for your Visual Studio version) and Embree.

Additional Prerequisites for GPU Build

To build OSPRay’s GPU module you need

CMake Superbuild

For convenience, OSPRay provides a CMake Superbuild script which will pull down OSPRay’s dependencies and build OSPRay itself. By default, the result is an install directory, with each dependency in its own directory.

Run with:

mkdir build
cd build
cmake [<OSPRAY_SOURCE_DIR>/scripts/superbuild]
cmake --build .

On Windows make sure to select a 64bit generator, e.g.

cmake -G "Visual Studio 17 2022" [<OSPRAY_SOURCE_DIR>/scripts/superbuild]

The resulting install directory (or the one set with CMAKE_INSTALL_PREFIX) will have everything in it, with one subdirectory per dependency.

CMake options to note (all have sensible defaults):

will be the root directory where everything gets installed.
sets the number given to make -j for parallel builds.
toggles installation of all libraries in separate or the same directory.
whether to enable volume rendering via Open VKL
set to OFF will download a pre-built version of Embree.
set to OFF will download a pre-built version of Open Image Denoise.
determines which version of Open Image Denoise to pull down.
set to ON to build OSPRay’s MPI module for data-replicated and distributed parallel rendering on multiple nodes.
enables beta GPU support, fetching the SYCL variants of the dependencies and builds OSPRAY_MODULE_GPU
set to ON to build TBB from source (required for ARM support). The default setting is OFF.

For the full set of options, run:

ccmake [<OSPRAY_SOURCE_DIR>/scripts/superbuild]


cmake-gui [<OSPRAY_SOURCE_DIR>/scripts/superbuild]

Cross-Compilation with the Superbuild

The superbuild can be passed a CMake Toolchain file to configure for cross-compilation. This is done by passing the toolchain file when running cmake. When cross compiling it is also likely that you’ll want to build TBB and Embree from source to ensure they’re built for the correct target, rather than the target the Github binaries are built for. It may also be necessary to disable specific ISAs for the target by passing BUILD_ISA_<ISA_NAME>=OFF as well.

mkdir build
cd build
cmake --toolchain [toolchain_file.cmake] [path/to/this/directory]
    <other arguments>

While OSPRay supports ARM natively, it may be desirable to cross-compile it for x86_64 to run in Rosetta depending on the application integrating OSPRay. This can be done using the toolchain file toolchains/macos-rosetta.cmake, and by disabling all non-SSE ISAs when building. This can also be done by launching an x86_64 bash shell and then compiling as usual in this environment, which will cause the compilation chain to target x86_64. The BUILD_ISA_<ISA NAME>=OFF flags should be passed to disable all ISAs besides SSE4 for Rosetta:

arch -x86_64 bash
mkdir build
cd build
cmake [path/to/this/directory]
    <other arguments>

Standard CMake Build

Compiling OSPRay on Linux and Mac OS X

Assuming the above requisites are all fulfilled, building OSPRay through CMake is easy:

Compiling OSPRay on Windows

On Windows using the CMake GUI (cmake-gui.exe) is the most convenient way to configure OSPRay and to create the Visual Studio solution files:

Alternatively, OSPRay can also be built without any GUI, entirely on the console. In the Visual Studio command prompt type:

cd path\to\ospray
mkdir build
cd build
cmake -G "Visual Studio 17 2022" [-D VARIABLE=value] ..
cmake --build . --config Release

Use -D to set variables for CMake, e.g., the path to Embree with “-D embree_DIR=\path\to\embree”.

You can also build only some projects with the --target switch. Additional parameters after “--” will be passed to msbuild. For example, to build in parallel only the OSPRay library without the example applications use

cmake --build . --config Release --target ospray -- /m

Finding an OSPRay Install with CMake

Client applications using OSPRay can find it with CMake’s find_package() command. For example,

find_package(ospray 3.0.0 REQUIRED)

finds OSPRay via OSPRay’s configuration file osprayConfig.cmake1. Once found, the following is all that is required to use OSPRay:

target_link_libraries(${client_target} ospray::ospray)

This will automatically propagate all required include paths, linked libraries, and compiler definitions to the client CMake target (either an executable or library).

Advanced users may want to link to additional targets which are exported in OSPRay’s CMake config, which includes all installed modules. All targets built with OSPRay are exported in the ospray:: namespace, therefore all targets locally used in the OSPRay source tree can be accessed from an install. For example, ospray_module_cpu can be consumed directly via the ospray::ospray_module_cpu target. All targets have their libraries, includes, and definitions attached to them for public consumption (please report bugs if this is broken!).

  1. This file is usually in ${install_location}/[lib|lib64]/cmake/ospray-${version}/. If CMake does not find it automatically, then specify its location in variable ospray_DIR (either an environment variable or CMake variable).↩︎