gsplat: CUDA Gaussian Splatting for Python Pipelines

What gsplat actually is, and who it is for

The README describes gsplat as "an open-source library for CUDA accelerated rasterization of gaussians with python bindings." That phrasing matters. This is not a viewer, a desktop application, or a hosted service. It is the rasterization core that sits between your optimizer and your rendered image, exposed as Python-callable operations backed by CUDA kernels.

The project states it was inspired by the SIGGRAPH paper 3D Gaussian Splatting for Real-Time Rendering of Radiance Fields, and that the authors made it faster and more memory efficient with additional features. So the intended user is someone who already understands the Gaussian Splatting pipeline: a set of 3D Gaussians with position, scale, rotation, opacity and spherical-harmonics color, projected to screen space and alpha-composited into pixels. If that sentence reads as a complete description of your problem, gsplat is aimed at you. If it reads as jargon, the library will not help, because it does not include a data pipeline, a training loop, or a UI.

The practical audience is therefore researchers and engineers writing their own trainer, or extending one. The repository ships examples/simple_trainer.py and examples/simple_trainer_2dgs.py, which is the clearest signal of intent: the library expects you to write the loop, and it supplies the differentiable renderer you call inside it.

How the rasterization path is organized

Based on the repository layout, everything importable lives under the gsplat/ package directory, and a README note under the v1.6.0 changes confirms this was deliberate: "Simplified package layout -- everything now lives under the gsplat namespace." The third_party/ directory holds vendored dependencies, and profiling/ plus tests/ sit alongside the package, which is what you would expect from a project whose main risk is kernel correctness rather than API surface.

The data flow the README implies is conventional for this class of renderer. Gaussians are projected through a camera model, sorted or bucketed into screen-space tiles, and blended front to back. gsplat's differentiators are in how those steps are scheduled and fused. The April 2026 AccuTile change adds "a conservative ellipse-based tile-Gaussian intersection test on the 3DGS path for tighter work scheduling before rasterization," which is a scheduling optimization: fewer tile-Gaussian pairs get queued, so less work is thrown away later. The June 2026 Gaussian ID rasterization op goes the other direction, exposing per-pixel identity, counts and "top contributors" rather than color, which is useful when you need to know which Gaussians produced a pixel instead of what color it ended up.

The camera and sensor layer has expanded well beyond a single pinhole model. The README lists pinhole, FTheta, fisheye and LiDAR models, with LiDAR rasterization arriving in March 2026 including spinning-lidar camera models, eval3d rendering and depth or hit-distance modes. That breadth is a design commitment: gsplat is not assuming you captured with a standard perspective camera. It also means the surface area you must understand before trusting an output is larger than the name suggests.

Installing gsplat and running a first render

The README is explicit that PyTorch must be installed first, before anything else. The simplest install is from PyPI, and the README notes that this path builds the CUDA code on the first run through JIT compilation. That means the first import is slow and requires a working CUDA toolchain on the machine, not just a wheel download.

pip install gsplat

If you would rather pay the build cost at install time instead of at first run, the README gives the source install, which compiles the CUDA code during installation.

pip install git+https://github.com/nerfstudio-project/gsplat.git

There is a third path for people who want neither a JIT build nor a full source compile. The project publishes pre-compiled wheels for Linux and Windows on certain python-torch-CUDA combinations, and the README warns that with this route you must install gsplat's dependencies manually. It points at setup.py for the dependency list. The README's own example targets PyTorch 2.0 with CUDA 11.8.

pip install ninja numpy jaxtyping rich
pip install gsplat --index-url https://docs.gsplat.studio/whl/pt20cu118

Note the mismatch worth checking before you copy that: the pyproject.toml in the repository requires torch>=2.7, while the README's wheel example is labelled for pytorch 2.0. The wheel index has per-combination paths, so the pt20cu118 index is a different build from whatever main currently targets. Confirm your combination exists at https://docs.gsplat.studio/whl rather than assuming the README example is current.

For a first real use, the repository provides examples/simple_trainer.py, and the README points Windows users at a tutorial video by Jonathan Stephens covering how to install gsplat and get started with 3DGUT. Running the trainer against a scene is the honest smoke test: it exercises projection, rasterization and the backward pass, which a simple import does not. The examples/requirements.txt file lists what the example scripts need beyond the library itself.

Where gsplat is the wrong tool

The most concrete limitation is visible in the README's own release notes. The v1.6.0 section is headed "Changes on main since the v1.5.3 tag (not yet on PyPI)." Everything listed there, including sparse 3DGS rasterization, multi-GPU dense 3DGS, orthographic-camera support for 3DGUT, and the SE(3) fused operations, is on main and not in the published package. If you install from PyPI, you are getting the v1.5.3 line, and the most recent release in the repository is v1.5.3 from 2025-07-04. Anyone reading the news section and expecting those features from pip will be disappointed. The only way to get them is the source install.

The second limitation is hardware. Nothing in the README describes a CPU fallback or a non-NVIDIA path, and the library is described as CUDA accelerated throughout. setup.py does expose a BUILD_NO_CUDA environment variable defaulting to "0", which suggests a build without CUDA is possible, but the README does not document what such a build can actually do. Treat that as a build flag, not a supported deployment mode. If you are on AMD hardware, the search results people generate for this project include "GSplat AMD", which tells you the question is common; the README does not answer it.

The third limitation is scope. gsplat renders Gaussians. It does not capture them, does not provide a reconstruction pipeline from images to Gaussians beyond the example trainers, and does not ship a viewer application, though examples/gsplat_viewer.py and examples/simple_viewer.py exist as starting points. If your actual need is "turn a phone video into a splat I can look at," you are looking at the wrong layer of the stack.

How gsplat differs from the INRIA reference and from Brush

The reference implementation from INRIA is the paper's original code, and the README positions gsplat as inspired by that work while claiming to be faster and more memory efficient. The difference in approach is packaging and scope rather than the underlying math. gsplat is a pip-installable library with Python bindings designed to be called from your own code, with a documented wheel index and a namespace layout under gsplat/. The INRIA codebase is a research release tied to the paper's training setup. If you want to reproduce the paper, the original is the direct route. If you want a renderer to call from a trainer you are writing, the library packaging is the point.

Against Brush, the distinction is architectural rather than about speed. Brush is a Rust and WebAssembly implementation that runs in the browser, which is why the search list pairs it with gsplat. That is a different deployment target: a browser-based tool cannot call CUDA kernels, so it necessarily takes a different path to the same visual result. gsplat's answer is to stay on the GPU through CUDA and accept the NVIDIA dependency. If your constraint is "runs anywhere a browser runs," gsplat is not a candidate, and no amount of kernel tuning changes that.

A more interesting comparison is with 3DGUT, which is not an alternative at all. NVIDIA's 3DGUT is integrated into gsplat, with a dedicated guide at docs/3dgut.md and a March 2026 note about external distortion support for windshield-style rigs. The README also lists PPISP as an alternative to bilateral grids for compensating training views. So gsplat's answer to competing methods is often absorption rather than competition, which is good for users and means the library's surface keeps growing.

Maintenance, versions and licence obligations

The repository is not archived, and the last push was on 2026-09-19, three days before this writing. The release cadence visible in the tags is slower than the commit cadence: v1.5.1 in April 2025, v1.5.2 in May 2025, v1.5.3 in July 2025, and then a long stretch of work on main that has not been tagged. That gap between main and PyPI is the main upgrade cost you should budget for. If you depend on features announced in the news section, you are tracking main, and tracking main means you own the breakage.

The build requirement moved with the v1.6.0 line: the README states PyTorch 2.7+ is now required, and pyproject.toml's build-system section lists torch>=2.7. If you are pinned to an older torch for other reasons, that pin and gsplat are in conflict. The README also notes improved CUDA 12.8 and 13.2 build compatibility and CUDA 13 plus NumPy 2 support, so the build matrix is being actively widened, but each combination is a separate thing to verify.

On licensing, the project is Apache-2.0, and the LICENSE file is at the repository root. The source files carry SPDX headers, and those headers show a mixed provenance: setup.py carries both a Regents of the University of California, Nerfstudio Team copyright and an NVIDIA copyright, while pyproject.toml carries an NVIDIA copyright. That is normal for a project that has absorbed contributions from multiple organizations, but it means the attribution chain per file is not uniform. Apache-2.0 includes a patent grant and requires that you preserve notices and state changes. This is not legal advice; if you are shipping gsplat inside a commercial product, have counsel read the LICENSE and the per-file headers rather than assuming the top-level identifier settles everything.

Editorial conclusion

Adopt gsplat if you have an NVIDIA CUDA GPU, PyTorch 2.7 or newer, and you want rasterization as a library inside your own trainer; the examples/simple_trainer.py script is the fastest way to confirm your toolchain works end to end. Do not adopt it if you need a point-and-click splatting application, if you are on AMD hardware, or if a pure-Python dependency tree is a hard constraint, because the PyPI package compiles CUDA kernels on first run and the pre-compiled wheel index only covers certain python-torch-CUDA combinations. Before committing, verify that your exact Python, torch and CUDA versions appear in the wheel index at https://docs.gsplat.studio/whl, and check whether the features you need (LiDAR, 3DGUT, sparse rasterization) sit on a released tag or only on main, since the v1.6.0 changes listed in the README are not yet on PyPI.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. nerfstudio-project/gsplat on GitHub
3. Project website
4. README
5. Releases