NVIDIAGameWorks/kaolin

Kaolin: A PyTorch Library for Accelerating 3D Deep Learning Research

TL;DR — Kaolin is NVIDIA's PyTorch library of reusable, GPU-optimized modules distilled from 3D deep learning research.

• Representation-agnostic physics (meshes, splats, point clouds) with Simplicits
• Differentiable rendering (DIB-R, nvdiffrast, easy_render PBR)
• First-class 3D Gaussian splats (PLY/USD I/O, densification, gsplat bridge)
• GPU octree acceleration structure: Structured Point Clouds (SPC)
• Conversions between 3D representations, quaternion ops, and USD I/O

Kaolin packages reusable building blocks from NVIDIA 3D research into a cohesive PyTorch API — continuously improving representation-agnostic physics simulation, fast conversions between representations, quaternion math, batched mesh and splat containers, I/O, visualization and more. See kaolin.readthedocs.io for tutorials and API reference, and developer.nvidia.com/kaolin for the NVIDIA Kaolin hub.

SIGGRAPH 2026

Join us in Los Angeles! Two sessions showcasing new Kaolin capabilities. Full details here.

Talk — Any Representation, Any Hardware, All Interactions Accelerating Interactive Prototypes Over Cutting Edge AI & 3D Research Sun 19 Jul 2026, 3:00–3:20 pm PDT · Room 408 A Maria Shugrina (NVIDIA / University of Toronto) Introduces Kaolin's new web client-server framework (kaolin/visualize/dash) for rapid prototyping of interactive browser interfaces over emerging AI and 3D research — patterns distilled from building interactive tools at SIGGRAPH technical papers, Real-Time Live, and Labs. Available on the web_framework_prerelease branch (not yet merged to master). Schedule →

Hands-on Lab — From 3D Captures to Simulated Digital Environments Thu 23 Jul 2026, 10:15–11:45 am PDT · Concourse Hall Clement Fuji Tsang, Vismay Modi, Maria Shugrina (NVIDIA) A capture-to-simulation pipeline for in-the-wild 3D Gaussian Splat scenes: segment objects, predict volumetric mechanical properties, run mixed splat–mesh physics — powered by recent Kaolin features. Export shareable USD files with Kaolin's custom physics schema. Bring your laptop and follow along hands-on. Full Conference badge required. Schedule →

Features

Experimental: Newton coupling — Simplicits soft bodies with rigid bodies, MPM, and articulated robots (rigid · MPM · Franka).

See the tutorial index and API reference at kaolin.readthedocs.io.

Installation

Starting with v0.12.0, Kaolin supports installation with pre-built wheels:

# Replace TORCH_VERSION and CUDA_VERSION with your torch / cuda versions
pip install kaolin==0.18.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-{TORCH_VERSION}_cu{CUDA_VERSION}.html

For example, kaolin 0.18.0 with PyTorch 2.8.0 and CUDA 12.8:

pip install kaolin==0.18.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-2.8.0_cu128.html

See the installation guide for the full torch/CUDA compatibility matrix and source install instructions.

python -c "import kaolin; print(kaolin.__version__)"

Quickstart

import kaolin
print(kaolin.__version__)

Load a 3D Gaussian splat from PLY or USD:

import kaolin
from kaolin.rep import GaussianSplatModel

gs = kaolin.io.import_gaussiancloud("scene.ply")
print(gs)  # GaussianSplatModel with positions, scales, rotations, opacities, ...

Simulate a mesh with Simplicits — see the physics tutorial.

Render a mesh with the easy PBR API:

import kaolin as kal

mesh = kal.io.obj.import_mesh("model.obj")
camera = kal.render.easy_render.default_camera(512)
lighting = kal.render.easy_render.default_lighting()
result = kal.render.easy_render.render_mesh(camera, mesh, lighting=lighting)

News

Unreleased (master or staging)

Recent work on master since v0.18.0:

• FreeForm / RKPM (CVPR 2026) — mesh-free, reduced-order deformable simulation for meshes and Gaussian splats. Builds skinning eigenmodes with a Reproducing Kernel Particle Method (RKPM) basis instead of per-shape neural-field optimization — about 40× faster training and lower error vs. FEM. Now integrated in Kaolin Simplicits.
• Web client-server framework (kaolin/visualize/dash) — rapid prototyping of interactive Web UIs over AI and 3D research (web_framework_prerelease branch; SIGGRAPH 2026 talk)
• GaussianSplatModel and PointSamples tensor-container API
• PLY/USD gaussian I/O with feature preservation
• USD physics schema — materials, skinned physics, subset features
• gsplat batched camera converters
• Newton coupling — soft bodies with rigid/MPM/Franka (notebooks)
• Simplicits Easy API save/load redesign and collision friction fixes
• FlexiCubes now Apache 2.0 at kaolin/ops/conversions/flexicubes/

v0.18.0 highlights

• Collisions in the physics module
• 3D gaussians → voxelgrid conversion and volume densifier
• Mesh + gaussian physics with 3DGRUT rendering
• FlexiCubes relicensed to Apache 2.0

See release notes for details.

Tutorials

Notebooks live under examples/tutorial/. Highlights by topic:

Physics

• Simulate a mesh with Simplicits
• Simulate a Gaussian splat
• Mesh + splat physics with 3DGRUT
• Newton rigid-body coupling

Gaussians

• Working with GaussianSplatModel

Rendering

• DIB-R differentiable rendering
• Easy mesh render
• Camera and rasterization

Structured Point Clouds

• Understanding SPCs

Visualization

• Interactive visualizer
• GLTF visualization

Full index: tutorial index.

Ecosystem

Projects built with Kaolin:

• FreeForm / RKPM — mesh-free reduced-order simulation via RKPM skinning eigenmodes (CVPR 2026)
• VoMP — feed-forward volumetric mechanical property fields for splats, meshes, and NeRFs (ICLR 2026)
• ArtisanGS — interactive Gaussian splat selection and segmentation with AI + human in the loop
• TRON — relightable 3D Gaussian reconstructions with a single-step neural renderer
• 3DGRUT — ray tracing and hybrid rasterization of Gaussian particles
• 3DGUT — joint mesh and Gaussian splat rendering (CVPR 2025 oral)
• Diffusion Texture Painting — interactive diffusion-based texture painting on 3D meshes (SIGGRAPH 2024)
• NVIDIA Kaolin Wisp — neural fields engine (NeRF, NGLOD, instant-ngp)
• gsplat — CUDA Gaussian splatting with Kaolin camera bridge
• NVIDIA Newton — physics engine with experimental Kaolin coupling
• Neural Geometric LOD (nglod) — SPC ray tracing
• FlexiCubes — gradient-based mesh extraction (SIGGRAPH 2023)
• DefTet — deformable tetrahedral mesh reconstruction
• DIB-R — single-image 3D reconstruction
• gradSim — differentiable simulation
• Text2Mesh — text-driven mesh stylization

Contributing

Please review our contribution guidelines.

License

Kaolin is released under the Apache License 2.0. A default import kaolin gives you the full Apache-licensed library.

The kaolin/non_commercial/ package is legacy only — kept for backward compatibility with older import paths (e.g. the pre-Apache FlexiCubes copy). New code should use the Apache-licensed modules under kaolin/ops/, kaolin/rep/, and the rest of the package tree.

Citation

If you use Kaolin in your research, please cite:

@software{KaolinLibrary,
  author  = {Tsang, Clement Fuji and Shugrina, Maria and Lafleche, Jean-Francois and Perel, Or and Loop, Charles and Takikawa, Towaki and Modi, Vismay and Zook, Alexander and Wang, Jiehan and Chen, Wenzheng and Shen, Tianchang and Gao, Jun and Jatavallabhula, Krishna Murthy and Smith, Edward and Rozantsev, Artem and Fidler, Sanja and State, Gavriel and Gorski, Jason and Xiang, Tommy and Li, Jianing and Li, Michael and Lebaredian, Rev},
  title   = {{Kaolin: A PyTorch Library for Accelerating 3D Deep Learning Research}},
  version = {0.18.0},
  date    = {2024-11-20},
  url     = {https://github.com/NVIDIAGameWorks/kaolin}
}

Contributors

Current team: Clement Fuji Tsang (Technical Lead), Maria (Masha) Shugrina (Manager), Charles Loop, Vismay Modi, Or Perel

Other major contributors: Alexander Zook, Donglai Xiang, Wenzheng Chen, Sanja Fidler, Jun Gao, Jason Gorski, Jean-Francois Lafleche, Rev Lebaredian, Jianing Li, Michael Li, Krishna Murthy Jatavallabhula, Artem Rozantsev, Tianchang (Frank) Shen, Edward Smith, Gavriel State, Towaki Takikawa, Jiehan Wang, Tommy Xiang