Faster Gaussian Splatting

May 28, 2026 · View on GitHub

PyTorch  CUDA  License: Apache-2.0

Progress accelerates when feedback cycles shrink.
Ever wondered how much faster you could iterate in your 3D Gaussian Splatting research by unifying the most impactful advances from its many follow-up works?
This repository presents our answer: the official implementation of “Faster-GS: Analyzing and Improving Gaussian Splatting Optimization”, an updated baseline for 3DGS optimization.

Faster-GS: Analyzing and Improving Gaussian Splatting Optimization
Florian Hahlbohm, Linus Franke, Martin Eisemann, Marcus Magnor
CVPR, June 2026
Project page | Paper | BibTeX

Overview

Faster-GS is a highly-optimized yet readable and extensible 3DGS implementation. Compared to other research codebases that are currently available, it is roughly 2-5x faster and uses less VRAM. We achieve this by combining ideas from multiple 3DGS follow-up works with our own improvements. If you are interested in the details, we recommend you read our paper.

This repository has different branches that provide variants of Faster-GS. While we intentionally kept these variants separate to improve readability and modularity, there are no fundamental limitations with combining their respective features.

The main branch provides our fast 3DGS implementation with many additional features. We hope that their joint availability within an optimized framework will accelerate future research.

  • Anti-aliasing improvements based on Mip-Splatting
  • MCMC densification based on 3DGS-MCMC
  • Different Gaussian truncation modes enabled by a revised opacity interpretation within the rasterizer
  • Improved random initialization through visibility and/or mask-based carving
  • Random background color training to reduce false transparency
  • Even faster training through informed pruning from Speedy-Splat
  • Handling of photometric variations in input images through PPISP

On the FasterGSFused branch, we went full nerd-mode and fused the backward pass and optimizer. It provides an additional speedup over our default implementation and also uses less VRAM. And the best part is that the code is still pretty clean. Great if you need every bit of performance or just like to train extra fast.

The FasterGS4D branch provides an extension of our implementation to dynamic scene reconstruction with 4D Gaussians. Compared to the original implementation by Yang et al., ours trains significantly faster and uses less VRAM without sacrificing quality.

The FasterGSTestbed branch contains the implementation we used to develop, integrate, and evaluate all improvements we discuss in our paper. It allows you to individually enable/disable the components we evaluate in the ablation study of our paper. This branch is a great starting point if, for example, you can not afford the extra VRAM required by the improved backward pass and want to develop a VRAM-optimized implementation.

On the FasterGSBasis branch, we provide our basis implementation described in the appendix of our paper. All other variants are built on top of this basis. We used it to develop and test multiple minor algorithmic and cleanup changes to ensure that they do not affect quality.

Installation

Our implementation is provided as an extension to NeRFICG, a radiance field and view synthesis framework actively maintained and developed by our research group.

Easy integration into existing codebases:
We understand that for compatibility with previous or current projects you might not be able to immediately switch from your current 3DGS framework. Therefore, we tried to make it as easy as possible to integrate the most impactful improvements into existing codebases. Our CUDA backend can be installed into an existing environment as a PyTorch extension through the following command:

pip install git+https://github.com/nerficg-project/faster-gaussian-splatting/#subdirectory=FasterGSCudaBackend --no-build-isolation

Integrating the key features of this extension into the official 3DGS codebase (graphdeco-inria/gaussian-splatting) requires only minimal code changes.
A reference implementation is available here.

That being said, we encourage you to give the native implementation a shot as it provides the full performance improvements as well as a ton of additional features. We also tried to make the code as readable and extensible as possible by optimizing and refactoring the PyTorch and CUDA code of all integrated methods.

Requirements

Setup

As a preparatory step, the NeRFICG framework needs to be set up. Please follow the instructions in its README to set up a compatible Conda environment.

Now add Faster-GS as an additional method by cloning this repository into src/Methods/FasterGS:

# HTTPS
git clone https://github.com/nerficg-project/faster-gaussian-splatting.git src/Methods/FasterGS

or

# SSH
git clone git@github.com:nerficg-project/faster-gaussian-splatting.git src/Methods/FasterGS

Next, install all method-specific dependencies and CUDA extensions using:

python ./scripts/install.py -m FasterGS

Note: The framework determines on-the-fly what extra modules need to be installed. Sometimes this causes unnecessary errors/warnings that can interrupt the installation process. In this case, first try to rerun the command before investigating the error in detail.

Variants

Installing one of our Faster-GS variants (e.g., FasterGS4D) from their respective branch can be achieved by

# HTTPS
git clone --single-branch -b FasterGS4D https://github.com/nerficg-project/faster-gaussian-splatting.git src/Methods/FasterGS4D

or

# SSH
git clone --single-branch -b FasterGS4D git@github.com:nerficg-project/faster-gaussian-splatting.git src/Methods/FasterGS4D

and then

python ./scripts/install.py -m FasterGS4D

Usage

The Faster-GS method is fully compatible with the NeRFICG scripts in the scripts/ directory. This includes config file generation via create_config.py, training via train.py/sequential_train.py/benchmark.py, inference and performance benchmarking via inference.py, exporting trained models to .ply files via convert_to_ply.py, and interactive rendering via gui.py.

For detailed instructions, please refer to the NeRFICG repository.

Acknowledgements

This work was partially funded by the DFG projects Real-Action VR (ID 523421583) and Increasing Realism of Omnidirectional Videos in Virtual Reality (ID 491805996).
Linus Franke was supported by the ERC Advanced Grant NERPHYS (ID 101141721).

We thank the authors of the following works, whose ideas and open-source implementations form the foundation of this project:

We also thank Janusch Patas (aka. MrNeRF) for partially inspiring this project with his open-source bounty for LichtFeld Studio, where an early version of our work was the winning submission and has since become one of its core components.

License and Citation

This project is licensed under the Apache License 2.0 (see LICENSE).

If you use this project in your research, please cite our paper:

@misc{hahlbohm2026fastergs,
  title         = {Faster-GS: Analyzing and Improving Gaussian Splatting Optimization},
  author        = {Florian Hahlbohm and Linus Franke and Martin Eisemann and Marcus Magnor},
  year          = {2026},
  eprint        = {2602.09999},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CV},
  url           = {https://arxiv.org/abs/2602.09999},
}