PlotOptiX puts an OptiX 9.1 path tracer behind a four-line Python plot

PlotOptiX renders data as lit primitives rather than flat markers

PlotOptiX is a Python package for rendering 3D data with ray tracing, built on the OptiX 9.1 framework and aimed at visualising large datasets, and small ones as well. The audience is narrow and specific: engineers and researchers who already have a CUDA enabled GPU with compute capability of at least 7.5, an NVIDIA driver of r590 or newer, and a dataset that looks like noise in a flat scatter plot.

The rendering model is what separates it from a plotting library. Data features are represented as a position, a size or thickness, and a color of primitives in several basic shapes, or projected onto the surfaces of objects as a color texture and a displacement map. Triangular meshes generated in code or loaded from a file are supported too. The payoff is a photorealistic image with physically based lighting and depth of field, where overlapping points cast real shadows. The cost is that the picture is produced by tracing rays on a GPU, so the same script that draws a scatter plot on a laptop without a discrete card will not run here.

The scene graph is fixed: cameras, geometries, shading, lights

Under the hood PlotOptiX is a set of CUDA shaders written by R&D Team, wrapped in C# and C++ libraries and exposed through a Python API. The project documentation states that you do not need to write shaders, implement intersection algorithms, or handle 3D scene technicalities, so the Python layer is a scene description surface rather than a renderer you configure by hand.

Five families of object make up a scene. Cameras include orthographic, pinhole, thin-lens and fisheye, with depth of field, a vintage lens bokeh swirl and chromatic aberration simulation, a panoramic camera for 360 degree environment maps, and a user defined projection that can shoot rays at any angle from any origin. Geometries cover particles, parallelepipeds, parallelograms, tetrahedrons, linear segments, bezier curves and b-splines, with meshes shaded or wireframe, generated from a parametric surface or from f(x,y) data, defined by vertices and faces, or loaded from a Wavefront .obj file. Surfaces run from flat to diffuse, reflective and refractive, with light dispersion, roughness, metalness, volume scattering and nested volumes. Light sources are spherical or parallelogram, with emission inside volumes and uniform or mapped environmental light. The renderer is a progressive path tracer with explicit light sampling, so an image refines across frames.

Windows is ready to go, Linux asks for Mono, pythonnet and FFmpeg

Installation is where this project gets uneven, and the platform difference is not cosmetic. The README states that binaries are tested in Windows 11 with any Python 3, and on Linux with Python 3.8 to 3.14, on Ubuntu 26.04. Windows is described as ready to go in most cases. Linux needs more typing: FFmpeg shared libraries of version 8.0 or newer, the Mono Common Language Runtime of version 6.6 or newer, and pythonnet, which is what lets the Python API reach the C# and C++ libraries underneath. Python itself must be 64-bit.

The package also performs its own environment checks before it installs anything. The setup script shells out to the CUDA compiler to report which toolkit is present, and refuses to continue when the interpreter is not 64-bit. That logic is visible in the setup.py file:

from setuptools import setup, find_packages
import struct, os, platform, subprocess
def HandlePrerequisites(command_subclass):
    base_run = command_subclass.run
    def testPython64b(self):
        if struct.calcsize("P") * 8 != 64:
            print(80 * "*"); print(80 * "*")
            print("Python 64-bit is required.")
            print(80 * "*"); print(80 * "*")
            raise ValueError

If nvcc cannot be reached on Linux, the fallback path looks in /usr/local/cuda/bin. The repository also carries gcp_install_gpu.txt with installation steps for a Google Compute Engine instance with two V100 GPUs, where FFmpeg is not included.

A first plot is four lines, and the example ships a million points

The usage path is short enough to show in full. The example the project presents creates a TkOptiX instance, hands it a set of random positions and radii, and opens the window. The radius argument is what turns each sample into a lit sphere rather than a flat disc.

   import numpy as np
   from plotoptix import TkOptiX

   n = 1000000                                  # 1M points, better not try this with matplotlib
   xyz = 3 * (np.random.random((n, 3)) - 0.5)   # random 3D positions
   r = 0.02 * np.random.random(n) + 0.002       # random radii

   plot = TkOptiX()
   plot.set_data("my plot", xyz, r=r)
   plot.show()

Two details matter for a first run. The project can run as a Tkinter based simple GUI window or as a headless raytracer, so a server without a display is still a valid target. And because the renderer is progressive, the first frames are noisy and settle as accumulation proceeds, with callbacks available at scene initialisation, at the start and end of each frame, and at the end of progressive accumulation. Examples for practical code samples live in the examples directory of the repository, and a complete API reference sits on the documentation site plotoptix.rnd.team.

Zero-copy buffers let CuPy and PyTorch tensors drive the scene

The parts of PlotOptiX that go beyond drawing points matter most for anyone building an interactive or animated scene. Image output is available at 8, 16 or 32 bits per sample, in HDR, either written to a numpy array or saved to common image file formats. Beyond that, GPU buffers are wrapped in numpy arrays with zero copy, including 8 and 32 bit per channel images, hit and object information, albedo and normals. So the renderer can hand back the buffers it already holds without a round trip through host memory.

Texture and geometry updates can come straight from CuPy or PyTorch tensors, whether they live on the GPU or on the CPU, which is the path to animating a dataset without re-uploading it each frame. Post processing includes tonal correction curves, levels adjustment, mask and overlay application, and AI denoisers and upsamplers using both OptiX native models and Intel Open Image models. Video output to MP4 is hardware accelerated through NVENC 13.0, and multi-GPU support is configurable. The result is a package that behaves more like a rendering engine with a Python front end than like a plotting library.

Colab ships an older release because its drivers are older

The clearest sign of how tightly this project is bound to its drivers shows up in Google Colab. The project links a Colab notebook with the setup and a simple generated image, and adds that Colab drivers usually are not up to date, so the most recent PlotOptiX release may not be compatible with what Colab provides. The sample notebook is configured to install a release that does work with the available driver. In practice this means the newest feature set is unavailable on shared notebooks, and that your working version depends on the moment you installed it.

Other constraints follow from the same dependency chain. A GPU with compute capability below 7.5 is out, and so is a driver older than r590. The C# and C++ core means a Mono runtime on Linux, which is an unusual dependency for a Python package and one that has to match the runtime version the library was built against. The README does not document a rollback procedure for a failed upgrade, and it does not document how to run without a GPU, so a machine without an NVIDIA card has no supported path through the project as described.

The comparison with matplotlib is about rendering, not about syntax

The project positions PlotOptiX against the matplotlib 3D scatter example, and the comparison is worth reading carefully rather than at face value. The claim is that basic usage is even more simple than with matplotlib, and that PlotOptiX is much faster on large data and, with the ray traced shading and depth of field, more readable. The million point example carries the comment that trying that size with matplotlib is a bad idea.

The syntax does look simpler, because set_data takes positions and an optional radius instead of a scatter call with per point styling. The performance and readability claims are harder to judge without running both, and they come from the project itself rather than from an independent measurement. What is clear is the shape of the trade. matplotlib produces a figure as quickly as the interpreter can loop over your arrays, on any machine, in a format that survives a paper. PlotOptiX produces a rendered image through a progressive path tracer, on hardware you may have to rent, at a resolution and quality that a figure library does not attempt.

Releases follow the OptiX and CUDA versions, and the licence is custom

Version history here tracks the graphics stack underneath rather than a feature roadmap. v0.19.0 arrived on 2026-03-26 with OptiX 9, v0.19.1 on 2026-05-29 with OptiX 9.1 and CUDA 13.2, and v0.19.2 on 2026-08-02 with denoisers and intersections. The last push to the master branch was on 2026-08-09. The repository is not archived, and the project ships a CHANGELOG.rst alongside the README, the docs directory and the examples directory, so upgrade notes exist for anyone tracking changes.

Licensing is the item to read closely. GitHub classifies the licence as Other, a custom licence that the platform cannot map to a standard identifier, and the terms live in LICENSE.txt with related files under a licenses directory. There is no statement here about what that licence permits, so treat it as unknown until you read the file and decide for yourself what your use requires. That matters for a package meant for commercial and research pipelines alike, since a renderer that becomes part of a production image pipeline inherits whatever restrictions its licence carries.

Editorial conclusion

PlotOptiX is worth adopting if you already own a CUDA GPU with compute capability of 7.5 or better, your data reads as noise in a flat scatter plot, and you can wait for a progressive path trace to converge. It is the wrong choice for CPU-only machines, for lightweight interactive exploration, or for pipelines that need reproducible numbers instead of pictures. Verify first that your driver is r590 or newer, that the release you install matches your OptiX version, and that the terms in LICENSE.txt fit your use, because the licence is custom and GitHub cannot classify it.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. rnd-team-dev/plotoptix on GitHub