# 2d-gaussian-splatting: no releases, a CUDA rasterizer submodule to install by hand, and a warning that stops mid-sentence

> This is the official implementation of 2D Gaussian Splatting, representing a scene as oriented disks that are rasterized and fused into a mesh. It has no GitHub releases, its changelog entries stop two years before its last commit, its CUDA rasterizer is a separate submodule with its own install step, and its final warning about the preprocessed DTU data never finishes.

**hbb1/2d-gaussian-splatting** — [SIGGRAPH'24] 2D Gaussian Splatting for Geometrically Accurate Radiance Fields

- Repository: https://github.com/hbb1/2d-gaussian-splatting
- Website: https://surfsplatting.github.io
- Stars: 3,302 · Forks: 333
- Language: Python
- License: NOASSERTION
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/hbb1-2d-gaussian-splatting

## No releases, and a changelog that stops before the last commit

The repository has no GitHub releases, so there is no tag to pin and nothing to download but the source. That makes the dated New Features list the only changelog, and it is uneven. The newest entry is 2025/12/19, and it is not a code change at all: it says the work was featured in a LearnOpenCV blog post. Before that come two community viewer integrations from July 2024, a Colab notebook, and a SIBR Viewer note from June 2024. The last two entries that describe changes to the code are both from May 2024, one fixing a bug in unbounded meshing and one describing a 30% to 40% training speedup from CUDA operator fusing. The last commit on main is dated 2026-08-25, so there are commits well after the final documented change and no release to mark where they landed.

## The CUDA rasterizer is a submodule with its own install step

The tree carries `.gitmodules` and a `submodules/` directory, and the rasterizer itself lives in a separate repository by the same author, linked at the top of the README as the surfel rasterizer in CUDA. The clone is recursive for that reason:

```bash
git clone https://github.com/hbb1/2d-gaussian-splatting.git --recursive
```

The speedup entry says what happens when the copy is stale: existing users are told to update the submodule and reinstall it, with `git submodule update --remote` followed by `pip install submodules/diff-surfel-rasterization`. So the compiled extension and the Python code can and do drift apart, and the fix is a separate command rather than a reinstall of the project. There is a second path for people without that build: the README links a surfel rasterizer implemented in Python through a Colab notebook, so the algorithm is reachable without the CUDA extension at the cost of the speedup.

## The install block never changes directory, and asks for a 3DGS environment

The Installation section is four lines: the recursive clone, then a comment offering a choice between an existing environment used for 3dgs and a new one, then `conda env create --file environment.yml` and `conda activate surfel_splatting`, with the environment named surfel_splatting. Two things stand out. The clone line is not followed by a `cd` into the cloned directory, so `environment.yml` is read from wherever you happen to be, which means the documented sequence only works if you are already inside the repository or move there yourself. And the first comment invites you to reuse a 3D Gaussian Splatting environment, which is convenient and also means the CUDA toolchain, compiler and library versions are shared with another project rather than pinned by this one.

## Omit the meshing flags and the script estimates them from your cameras

Bounded mesh extraction takes three arguments you are told to adjust: `--voxel_size` for voxel size, `--depth_trunc` for depth truncation, and `--depth_ratio` for mean versus median depth. The sentence that follows is the one to read twice: if these arguments are not specified, the script will automatically estimate them using the camera information. So the mesh you get is a function of your capture rig, not only of the trained model, and the difference between an explicit voxel size and an inferred one is invisible unless you know to look. Unbounded extraction is a different path with one flag, `--mesh_res`, given in the examples as 1024, and it works by contracting space into a sphere and applying adaptive TSDF truncation rather than fusing within a bounded volume.

## Two regularization weights with no defaults, and one flag used two ways

The regularizations are two command-line weights: `--lambda_normal` for normal consistency and `--lambda_distortion` for depth distortion. Neither has a default value, a suggested range or any tuning guidance in the README, so both are left to the reader. `--depth_ratio` is documented as 0 for mean depth and 1 for median depth, with 0 said to work for most cases, and the tips section recommends mean depth for unbounded or large scenes to reduce disk-aliasing artifacts. The DTU example then passes `--depth_ratio 1`, and also `-r 2`, a flag that appears nowhere in the documented argument list. That same example writes its model output to `output/date/scan105`, where the path segment looks like a slip for the dataset name.

## The warning about the preprocessed DTU data stops mid-sentence

The last thing in the README is a warning block that begins `In our **preprocessed DTU data` and does not finish. Whatever it was going to say about the preprocessed DTU data, which the README links to as a 3.5GB download alongside a COLMAP dataset, a reader is not told here. The custom dataset section above it does give the one piece of guidance that matters for your own captures: the same COLMAP loader as 3DGS is used, so scene preparation follows that project's instructions rather than a bespoke pipeline. Two paths are given for rendering a trained model, `render.py` with a model directory and a dataset directory, with `--skip_test` and `--skip_train` in the examples so a trained model can be meshed without repeating the evaluation.

## Every viewer in the README belongs to somebody else

The repository ships the training and export side: `train.py`, `render.py`, `view.py`, `convert.py` and `metrics.py`, with `arguments/`, `gaussian_renderer/`, `lpipsPyTorch/`, `scene/`, `scripts/` and `utils/` around them. Everything on the viewing side is external. The SIBR Viewer pre-built for Windows is a zip from the releases of a third-party monitoring project, and the launch command it documents is a path to that downloaded binary. The web viewer is GaussianSplats3D by another author, the remote viewer is built on Viser by someone else, and the Colab notebook was contributed separately. The community list goes further out still, listing gsplat documentation as the official rasterization API reference, SuperSplat as a WebGPU viewer, a LearnOpenCV guide to the pipeline, and a differentiable ray-tracing implementation of the surfel representation. There is no test directory in the tree and no test command in the README.

## Conclusion

2d-gaussian-splatting fits someone with a COLMAP or NeRF Synthetic capture who needs a geometrically accurate mesh rather than a splat to look at, and who is already set up for 3D Gaussian Splatting, since the README explicitly suggests reusing that environment. Three things to know before you start. There are no releases, so the code you get is whatever master holds, and the newest dated entry in the README's feature list is from December 2025 while the last commit is from 2026-08-25, so the changelog will not tell you what changed. The CUDA rasterizer is a submodule that has to be updated and pip-installed on its own, and a stale copy is exactly what the training-speed entry warns about. And when you mesh without passing the bounded parameters, the script derives them from your camera information, so mesh quality partly follows from the rig rather than from you. If you only need to view results, every viewer in this README is somebody else's repository.

## FAQ

### what is 2d gaussian splatting

A radiance field method that represents a scene as a set of 2D oriented disks, which the README calls surface elements or surfels, and rasterizes with perspective-correct differentiable rasterization. This repository is the official implementation of the SIGGRAPH'24 paper, and it adds regularizations plus meshing approaches on top of the representation.

### How do I install 2d-gaussian-splatting?

Clone it recursively, then create the conda environment: `git clone https://github.com/hbb1/2d-gaussian-splatting.git --recursive`, `conda env create --file environment.yml`, `conda activate surfel_splatting`. The recursive flag matters because the CUDA rasterizer is a submodule under `submodules/`, and installing it is a separate pip step.

### Do I need the CUDA rasterizer for 2d-gaussian-splatting?

There are two rasterizer paths. The CUDA one lives in a separate repository by the same author and is the submodule the recursive clone pulls in, and the README reports a 30% to 40% training speedup from fusing CUDA operators. A Python implementation is offered through a Colab notebook for anyone who cannot build the extension.

### How does 2d-gaussian-splatting choose mesh resolution?

For a bounded mesh, if you do not pass `--voxel_size`, `--depth_trunc` or `--depth_ratio`, the script estimates them from the camera information. For an unbounded mesh you pass `--mesh_res`, 1024 in the examples, and the method contracts space into a sphere and applies adaptive TSDF truncation.

### What license is 2d-gaussian-splatting released under?

The license field carries no value while a `LICENSE.md` sits at the root of the tree, so the terms are not identifiable from the metadata. The repository has no GitHub releases either, so there is no tagged artifact to compare against.

## Sources

- [hbb1/2d-gaussian-splatting on GitHub](https://github.com/hbb1/2d-gaussian-splatting)
- [Issues](https://github.com/hbb1/2d-gaussian-splatting/issues)
- [Project website](https://surfsplatting.github.io)
- [README](https://github.com/hbb1/2d-gaussian-splatting/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/hbb1-2d-gaussian-splatting