splatviz: Python 3D Gaussian Splatting Viewer and Editor

What splatviz is built to inspect

splatviz targets people working with 3D Gaussian Splatting data, especially researchers and developers who need to look inside rendered scenes instead of relying only on static images or training logs. The README describes live splat editing, side-by-side scene comparison, attachment to running 3DGS training, and inspection of render variables through Python snippets. That combination puts splatviz closer to an analysis and editing workspace than to a simple image viewer.

The project is a Python application built around a graphical interface. Its repository includes `run_main.py`, `splatviz.py`, renderer code, Gaussian Splatting modules, live-edit code, and separate widgets. The README names `pyimgui`, `imgui_bundle`, and `ImGUI` as GUI references. This makes splatviz relevant when the data is already in a form that its Gaussian object and renderer can load, rather than when the input is an arbitrary point cloud or an unrelated 3D application format. The README links to example scenes, but it does not provide a complete list of accepted scene formats.

splatviz also separates ordinary viewing from GAN mode. Version 1.2.0 moved GAN mode to the separate `ganviz` repository. That change matters for adoption because users looking for the original GAN-oriented workflow should not assume that every feature remains inside splatviz.

Rendering, editing, and evaluation in splatviz

The documented editing model is explicit: the Edit widget runs Python immediately before rendering, allowing a user to modify the Gaussian object while the scene remains visible. The README does not document a complete DSL or list the variables available to every snippet, so the exact editing API should be checked in the repository before building automation around it. It does clearly establish the execution point and the mutable object involved.

The Evaluate widget serves a different purpose. It exposes render variables and provides histogram visualization, which supports inspection of values produced during rendering rather than only visual comparison. The repository layout is consistent with a modular implementation: `renderer/` contains rendering-related code, `gaussian_splatting/` contains the scene representation, `widgets/` contains interface components, and `live_edit.py` provides a separate live-editing path. `presets.json` also indicates that the application includes saved or configurable interface state, although the README does not explain every preset field.

Scene comparison is supported through a multi-scene comparison feature. The README does not state whether comparison is limited to two scenes, whether cameras are synchronized, or whether results can be exported numerically. Those omissions make it important to inspect the interface and implementation rather than assuming a full benchmark or reporting suite.

The renderer depends on `diff-gaussian-rasterization`. The installation instructions require installing that project separately, which indicates that splatviz relies on a compiled CUDA rasterization component rather than being a pure Python renderer.

Installing splatviz and launching its first viewer

The README documents Linux and Windows support, but the installation path is specifically tied to CUDA and Python 3.10. The project requires `uv`, a matching CUDA Toolkit, and one CUDA-specific dependency extra. Install `uv` first with the command published by the project:

curl -LsSf https://astral.sh/uv/install.sh | sh

Then clone the repository and enter its directory:

git clone https://github.com/Florian-Barthel/splatviz.git
cd splatviz

Choose the extra that matches the installed CUDA Toolkit. The README lists these alternatives:

uv sync --extra cu118
uv sync --extra cu126
uv sync --extra cu128
uv sync --extra cu130

The `pyproject.toml` file restricts Python to `>=3.10,<3.11`, selects the corresponding PyTorch CUDA index for each extra, and declares the extras as mutually conflicting. After synchronizing the environment, install the rasterizer:

uv pip install --no-build-isolation git+https://github.com/ashawkey/diff-gaussian-rasterization.git

On Windows, the README says the 2022 Visual Studio C++ build tools may also be required:

winget install Microsoft.VisualStudio.2022.BuildTools

Start the application with:

python run_main.py

The documented result is the interactive viewer window. If OpenGL selects an incompatible version, the README gives this environment override:

export MESA_GL_VERSION_OVERRIDE=3.3

That variable is not described as a general application setting. It is a fallback for an OpenGL selection problem, so it should not replace checking the host graphics stack.

Attaching splatviz to a 3DGS training run

Live training inspection is a distinct mode. The launch command is:

python run_main.py --mode=attach

In this mode, splatviz connects to a running 3DGS training process and can support live editing during training. The default listening address is `127.0.0.1:6007`, and the README says the host and port can be changed with `--host` and `--port`. The loopback address is a sensible local default, but changing the host could expose the connection beyond the local machine. The README does not document authentication, access control, or the attach protocol, so network exposure should not be inferred from the availability of those options.

This mode is most useful when a developer wants to inspect changes while training rather than wait for a final scene file. However, the README does not document compatibility with every 3DGS training implementation. The separate `splatviz_network` repository is linked for live editing, which suggests that the integration has a defined external component. Confirm that the training process and expected data interface match the documented attach workflow before depending on remote or network-based inspection.

Compatibility limits and the rasterizer dependency

The main limitation is environmental rather than functional. splatviz requires Python 3.10, a CUDA Toolkit from the documented set, a matching `torch` extra, and a separately installed `diff-gaussian-rasterization` package. The README identifies Linux and Windows, while the application uses an OpenGL graphical window. This is a substantial setup boundary for anyone expecting a portable Python library or a headless viewer.

There is another mismatch between the package metadata and release naming. `pyproject.toml` declares the project version as `0.1.0`, while the repository's release history identifies version 1.3.0 as the latest listed release, published on 2026-05-12. The README does not explain whether `pyproject.toml` intentionally remains unversioned or whether release tags are maintained separately. Engineers should therefore use repository tags when selecting a release and inspect the package metadata before automating version discovery.

The project is not archived, and its last push was on 2026-05-20. Release 1.3.0 added a video widget, easier `uv` installation, external edit text support, and a resizable render window. Version 1.2.0 records fixes to the evaluation widget and rasterizer import, along with simpler camera and file-browser scene loading. That history does not establish performance levels, compatibility with every CUDA release, or stability across arbitrary hardware combinations.

Upgrading splatviz across CUDA versions

Each supported CUDA route is represented by a separate optional dependency group in `pyproject.toml`: `cu118`, `cu126`, `cu128`, and `cu130`. The `[tool.uv] conflicts` configuration prevents these extras from being installed together, while the explicit PyTorch indexes direct `torch` toward the appropriate CUDA wheel source. This keeps the intended dependency routes separate, but it does not tell a user which route will work with a particular GPU or driver.

The separate rasterizer installation adds another point to check during an upgrade:

uv pip install --no-build-isolation git+https://github.com/ashawkey/diff-gaussian-rasterization.git

The README links the rasterizer as a Git repository rather than pinning a version. Its README also does not document a compatibility matrix covering splatviz releases, CUDA Toolkit versions, PyTorch builds, or Python 3.10 patch releases. A reproducible deployment therefore cannot be defined from the listed commands alone. Pinning the splatviz tag and recording the CUDA and rasterizer revisions used by an existing installation would make later comparisons more exact, although the README does not prescribe that procedure.

Older release notes record a fixed rasterizer import in version 1.2.0. That is a sign that import compatibility has changed over time. It supports checking the new release in a separate environment when an existing visualization setup is operationally important.

Where splatviz differs from static inspection

A static rendering pipeline can produce images for comparison, but it does not provide the same interactive surface for editing Gaussian objects, examining render variables, or watching a training process. splatviz is a better fit when the question is not simply whether a final image looks correct, but why particular render values are present or how a scene changes during development.

A general-purpose 3D viewer may support different scene formats and broader platform coverage, but the README does not establish such capabilities for alternative tools. Conversely, a training-only visualization script may be lighter for a single experiment, while splatviz places editing, evaluation, scene comparison, video, and attachment features in one application. The relevant comparison is workflow alignment: splatviz is aimed at Python-centered 3DGS inspection, not at arbitrary 3D content authoring.

The README points to `ganviz` for GAN mode. That is a clear scope boundary. If the required workflow depends on GAN-specific behavior, the separate project is the documented destination rather than an assumed splatviz feature.

Editorial conclusion

Adopt splatviz if you need a Python desktop tool for inspecting 3DGS scenes or watching a training process, and verify Python, CUDA, OpenGL, and rasterizer compatibility first. Do not choose it for a headless or platform-independent deployment, since the documented launch path uses a graphical application and requires a compatible CUDA rasterizer.

Frequently asked questions

Official sources

1. Florian-Barthel/splatviz on GitHub
2. Issues
3. License: MIT
4. README
5. Releases