NVIDIA Kaolin: a PyTorch library for 3D deep learning, splats and differentiable rendering

What Kaolin actually packages, and who the target user is

Kaolin is not a framework you build an application on top of. It is a collection of modules that each solve one narrow problem in 3D deep learning, wrapped in a consistent PyTorch API. The README describes it as "reusable, GPU-optimized modules distilled from 3D deep learning research." That phrasing is accurate about the shape of the library: batched containers for meshes and splats, conversion routines between representations, quaternion and rigid-transform math, an octree acceleration structure, differentiable renderers, and I/O for USD and PLY.

The target user is a researcher or research engineer who already has a PyTorch training loop and needs a piece of 3D machinery inside it. If you are fitting a neural radiance field and want to rasterize Gaussians differentiably, or you have a mesh and want to simulate it as a deformable body, Kaolin supplies that component. It does not supply a training harness, a dataset loader for your data, or a model zoo.

The breadth is the point and also the risk. A single library that spans physics, rendering, octrees, quaternions and USD export will have uneven maturity across those areas. The README links tutorials for each, but the depth of documentation differs per module, and nothing in the repository suggests a single unified abstraction tying them together beyond "PyTorch tensors in, PyTorch tensors out."

How the modules fit together: tensors, batched containers, Warp and CUDA kernels

The architecture is a thin Python layer over compiled CUDA. At the top sit container classes: SurfaceMesh for batched meshes, GaussianSplatModel for splats, Structured Point Clouds (SPC) for the octree representation. These hold tensors on the GPU and expose operations that dispatch to kernels. Conversions between representations (mesh to voxel grid, point cloud to SPC, and so on) are the glue that lets you move data between modules without leaving the GPU.

Physics is the newest and most distinctive part. The README describes Simplicits as representation-agnostic: it simulates meshes, splats and point clouds with collisions, accelerated by NVIDIA Warp. That means the same simulation code path accepts different geometry types, which is unusual. Most physics engines assume a mesh. Whether the abstraction holds up under complex scenes is something the documentation does not quantify.

Rendering splits into three named backends: DIB-R, nvdiffrast, and easy_render for physically based rendering, with spherical harmonics and spherical gaussians for lighting. The camera and rasterization tutorial suggests a shared camera abstraction feeding the rasterizers. Splat support includes PLY and USD I/O, densification, and converters for gsplat cameras, which points at interoperability with the wider Gaussian splatting ecosystem rather than a walled garden.

The build itself is where the design shows through. setup.py imports torch at install time and refuses to proceed without it, and it compiles CUDA extensions against the architectures you list in TORCH_CUDA_ARCH_LIST. That is a deliberate choice with a cost: installation is coupled to your exact CUDA and PyTorch combination.

Installing Kaolin and running a first mesh or splat operation

The README points readers to kaolin.readthedocs.io for tutorials and API reference, and to developer.nvidia.com/kaolin for the NVIDIA hub. It does not print a pip command in the text available here, so treat the build as a source install driven by setup.py. The critical constraint is stated in setup.py itself: PyTorch must already be present, and its version must fall between 2.5.1 and 2.12.1.

Install PyTorch first, then Kaolin. The setup.py header names the environment variable that controls which CUDA architectures the extensions are built for:

TORCH_CUDA_ARCH_LIST
IGNORE_TORCH_VER

If your PyTorch version sits outside the supported window, setup.py raises ImportError with the message "Kaolin requires PyTorch >= 2.5.1, <= 2.12.1". The environment variable IGNORE_TORCH_VER exists to bypass that check, and setup.py downgrades the failure to a warning when it is set. Use it knowingly: the check is there because the CUDA extensions are compiled against PyTorch's headers, and a mismatch can surface as a crash at import rather than a clean error.

Once installed, the entry point for most work is a container object. The README lists a working_with_gaussians tutorial and a SurfaceMesh container, and the repository layout puts runnable notebooks under examples/tutorial/ with a subdirectory for physics:

ls examples/tutorial/
ls examples/tutorial/physics/

You should see the notebook files the README links, including simplicits_mesh.ipynb and working_with_gaussians.ipynb. Opening those is the fastest way to see the intended data flow, because the README's feature table links each tutorial next to the module it demonstrates. There is also a Jupyter 3D viewer documented under the Visualization section for inspecting results inside a notebook.

The version window and the CUDA build are the real adoption cost

The hard limitation is not a missing feature. It is the coupling between Kaolin, PyTorch and CUDA. setup.py enforces PyTorch >= 2.5.1 and <= 2.12.1 at install time and aborts otherwise. If your environment is pinned to an older PyTorch for other reasons, Kaolin will not install without IGNORE_TORCH_VER, and setting that flag does not make the compiled kernels compatible. It only silences the check.

Second, the build needs a CUDA toolchain. TORCH_CUDA_ARCH_LIST controls which architectures the extensions are compiled for, and a wrong value produces binaries that fail at runtime on your GPU rather than at build time. There is no mention of a CPU-only path. If your target is inference on a machine without an NVIDIA GPU, this library is the wrong tool, not a tool with a workaround.

Third, the API surface is large and the release cadence is irregular. The recent releases are v0.16.0 in July 2024, v0.17.0 in November 2024, and v0.18.0 in August 2025. The last push to the repository was on 2026-09-18. A gap of roughly nine months between minor releases means pinning to a tag is sensible, but it also means fixes you need may sit on master for a while. Note that a headline feature, the web client-server framework in kaolin/visualize/dash, lives on the web_framework_prerelease branch and, per the README, is "not yet merged to master." Do not plan around it unless you are willing to track a branch.

Finally, third_party/ and LICENSE.NSCL in the repository root signal that not everything ships under one licence. The top-level licence is Apache-2.0, but the presence of a separate NSCL file means you should check which components carry which terms before redistributing.

Kaolin versus PyTorch3D and gsplat as a starting point

The closest comparison is PyTorch3D, Meta's 3D library for PyTorch. Both offer batched mesh containers and differentiable rendering. The difference in approach is scope and hardware assumption. PyTorch3D is built around a rendering and mesh-manipulation core with a documented CPU fallback for many operations, which makes it easier to run in environments without NVIDIA hardware. Kaolin leans harder into CUDA-specific acceleration structures, most visibly the SPC octree, and into NVIDIA's own research output such as Simplicits and nvdiffrast. If your work is mesh rasterization and you need portability, PyTorch3D is the more natural fit. If you need a GPU octree with ray tracing and feature grids, or representation-agnostic physics, Kaolin is the one that has it.

For Gaussian splatting specifically, gsplat is a narrower and more focused option: it targets rasterization of splats and its camera conventions are common enough that Kaolin ships converters for them. Kaolin's angle is the surrounding apparatus (PLY and USD I/O, densification, a GaussianSplatModel container, and a bridge into Simplicits so a splat scene can be simulated). If you only need to rasterize splats in a training loop, the smaller library is less to install and less to keep in sync. If you want to segment a captured scene, predict mechanical properties and run mixed splat-mesh physics, that pipeline is what Kaolin is assembling, and the SIGGRAPH 2026 lab described in the README walks through exactly that capture-to-simulation flow.

Maintenance, releases and what upgrading costs you

The repository is not archived and the last push was on 2026-09-18, so development is current. The release history tells a different story about cadence: v0.16.0 on 2024-07-25, v0.17.0 on 2024-11-20, v0.18.0 on 2025-08-08. Three minor releases in roughly thirteen months. For a library that compiles CUDA extensions, that pace matters because each upgrade can force a rebuild and a PyTorch version check.

Upgrading is therefore not a version bump. It is a rebuild against a possibly different PyTorch, with TORCH_CUDA_ARCH_LIST set correctly, followed by re-running whichever tutorials cover the modules you use. The setup.py constraint means an upgrade to Kaolin v0.18.0 may also require moving your PyTorch version, which can cascade into other dependencies in the same environment. Budget for that as a maintenance task rather than a patch.

On licensing: the repository carries Apache-2.0 at the top level, and also LICENSE.NSCL and a third_party/ directory. Apache-2.0 is permissive and generally straightforward for commercial use, but the presence of a second licence file means the safe move is to read LICENSE.NSCL and the contents of third_party/ to determine which files it covers. This is not legal advice; it is a pointer to where the question is answered.

Editorial conclusion

Adopt Kaolin if you already train 3D models on NVIDIA GPUs with PyTorch inside the supported version window and you want batched mesh, splat and SPC containers plus differentiable rendering without writing the CUDA yourself. Skip it if you need CPU-only inference, a stable API across releases, or a pure Python dependency you can audit line by line. Before committing, verify three things on your own machine: that your PyTorch version falls inside the 2.5.1 to 2.12.1 range that setup.py enforces, that your CUDA toolkit matches the version you intend to build against, and that the specific module you need (Simplicits, nvdiffrast, the USD schema) is present in the release tag you plan to pin.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. NVIDIAGameWorks/kaolin on GitHub
4. README
5. Releases