NVIDIA/barney

NVIDIA/barney

Description: A Scalable (and Optionally, Data-Parallel) ANARI Multi-GPU Path Tracer

Language: C++

License: Apache-2.0

Stars: 31

Forks: 8

Open issues: 4

Created: 2025-10-15T01:52:34Z

Pushed: 2026-06-11T10:17:25Z

Default branch: main

Fork: no

Archived: no

README: 

Barney - A Multi-GPU (and optionally, Multi-Node) Implementation of the ANARI Rendering API

Build Status:  

DISCLAIMER: Though Barney has by now reached a stage where it can be expected to be reasonably stable and complete, it is still under active development. If you run into bugs, missing features, or simply broken/outdated documentation please report those at https://github.com/NVIDIA/barney

What is Barney?

Barney is a renderer that implements that ANARI Cross Platform Rendering API (https://www.khronos.org/anari/) primarily for NVIDIA OptiX and CUDA capable GPUs.

Multi-GPU and Multi-Node Parallel Rendering

Barney is highly scalable, and can be used for both local, single-GPU rendering (as I do on my laptop on a daily basis), as well as for parallel rendering on multi-GPU nodes, and even for MPI based data-replicated and/or data-parallel rendering:

• Single-GPU usage: For single GPU usage Barney works like any other

ANARI device; multiple GPus or MPI are *not* required to run Barney.

• Multi-GPU: Barney can also make use of more than one GPU. Barney can

either be used in *explicit* multi-GPU mode (where the ANARI app explicitly creates different devices for different GPUs, and then "tethers" those using a specific ANARI extension we have introduced for this purpose); or it can simply use *automatic* multi-GPU, where Barney will simply grab all available GPUs and split the work across them.

• Multi-Node: For cluster, cloud, or HPC environments Barney also

supports MPI-parallel rendering (if built with MPI support), in which case an MPI-parallel application can use Barney across multiple different GPUs and/or nodes.

Data Parallel and/or Data Replicated Rendering

Barney also supports both *data parallel* as well as *data replicated* rendering: In fully data replicated rendering each GPU (and/or each node) gets the exact same copy of all the scene content, and different GPUs render different portions of the final image (ie, this should make rendering the *same* content *faster*). In fully data parallel (also sometimes called "distributed") rendering the scene to be rendered is "distributed" across the different GPUs/nodes, so different GPUs get different parts of what is logically a single model; then barney will make sure that each GPU "sees" all content during rendering (in this mode, Barney will not get faster by adding more GPUs, but it can render models much larger than what a single GPU could have rendered). Barney also supports some intermediate modes where, for example, different nodes work data parallel, but all GPUs on a given node work data replicated, etc.

Primarily Focussed on Sci-Vis Content

Barney is primarily intended for the type and size of data one could encounter in a scientific visualization (sci-vis) content, when used from tools such as, for example, ParaView. Barney supports all the typical geometric types required by such applications (triangle meshes, spheres, cylinders, curves, etc), and also supports the typical scalar field/volume data types such as structured volumes as well as Block-Structured AMR and unstructured data (as far as these are currently supported by ANARI).

Path Tracer

Though clearly focussed on Sci-Vis, Barney is still a pretty capable ray/path tracer on its own, and will, if scene and material data is properly set up, also do HRDI environment map lighting, indirect illumiation, glossy and specular reflection/refraction; depth-of-field cameras; point-, directional, and to some degree area lights; volumetric scattering, etc. Barney will clearly not achieve the kind of correctness or realism that pure global illumination renderers like Mitsuba or PBRT will be able to achieve; but it is still expected to behave creditably on typical non-Sci Vis rendering content.

Building and Running

Barney is not a stand-alone "renderer" or "vis-tool"; it is a library with an API, and needs other applications to build towards it. As such, it is never "run" on its own; it also needs to be run from another application (e.g., hayStack, at http://github.org/ingowald/hayStack), or from any application that supports the ANARI API (see https://www.khronos.org/anari/).

Dependencies for building Barney

Barney is primarily intended for interactive (multi-)GPU rendering, but can also be built in a non-GPU configuration. Similarly, one of barney's most important features is MPI-based data parallel rendering, but can absolutely also be built---and used--without MPI. As such, dependencies depend on what exactly needs to get built:

One way or another, barney requires:

• cmake, for building
• a c++-20 compliant c++ compiler (gcc on linux, visual studio on windows, clang on mac)

For CUDA/OptiX Acceleration, it also requires:

• CUDA, version 12 and up.

• OWL (https://github.com/NVIDIA/owl). Note OWL gets pulled in as a git

submodule, no need to externally get and install.

• OptiX, as part of OWL. See documentation in OWL (https://github.com/NVIDIA/owl) for

where to get, and how to best install for OWL to easily find it)

For MPI-based data-parallel rendering:

• Building requires a working MPI install. *Running* barney

requires a CUDA-aware MPI, for *building* this should not matter. We typically develop under---and test with OpenMPI---4.1.6 or 5.0, but users have reported working with other MPI flavors such as MPICH.

Building Barney

The ANARI build of barney works in pretty much the same way (and with the same options), but requires a pre-built and installed ANARI-SDK from https://github.com/KhronosGroup/ANARI-SDK. As to the time of this writing, you need ANARI SDK version 0.15 (or next_release branch)

First, build and install the ANARI SDK (https://github.com/KhronosGroup/ANARI-SDK):

cd ANARI-SDK
mkdir build
cd build
cmake .. -DCMAKE_INSTALL_PREFIX=
cmake --build .. [ --config...