💻 computer science

ImprovedGS+: A High-Performance C++/CUDA Re-Implementation Strategy for 3D Gaussian Splatting

ImprovedGS+ is a high-performance C++/CUDA re-implementation of 3D Gaussian Splatting within the LichtFeld-Studio framework that leverages hardware-optimized kernels and adaptive scheduling to significantly reduce training time and parametric complexity while achieving superior reconstruction quality compared to state-of-the-art baselines.

Original authors: Jordi Muñoz Vicente

Published 2026-03-10

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jordi Muñoz Vicente

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to paint a hyper-realistic 3D landscape on a computer screen. The old way of doing this (called "3D Gaussian Splatting") is like using a bucket of paint and throwing thousands of tiny, random dots at the canvas. Some dots land where they should, but many are wasted, and the process is slow because the computer has to constantly check and re-check where every dot goes.

The paper introduces ImprovedGS+, which is like upgrading from a bucket of paint to a high-speed, laser-guided paint sprayer. It's a complete rewrite of the software code, moving from a "slow and flexible" language (Python) to a "fast and rigid" language (C++/CUDA) that talks directly to the computer's graphics card.

Here is how they made it faster and better, using simple analogies:

1. The "Smart Split" (Long-Axis-Split)

The Problem: In the old method, when the computer needed more detail in a specific spot, it would copy a dot and split it into two, often blindly. It was like a baker cutting a loaf of bread into two random pieces, hoping one fits the shape of the sandwich.
The Solution: ImprovedGS+ uses a Long-Axis-Split. Imagine instead of cutting randomly, the baker looks at the loaf, sees it's long and thin, and slices it perfectly along its length.

How it works: The software identifies the "longest" direction of a 3D dot and splits it only in that direction.
The Result: This is done instantly on the graphics card (GPU) without the computer's main brain (CPU) having to stop and talk to it. It's like the baker having a laser cutter that slices the bread in one nanosecond, rather than a human using a knife.

2. The "Edge Detective" (Laplacian Filter)

The Problem: The old method sometimes got confused by flat surfaces (like a blank wall) and added too many dots, creating "noise" or static, like a TV with bad reception.
The Solution: The team built a custom "Edge Detective" that runs directly on the graphics card. It looks at the image and only adds new dots where there are sharp edges or real shapes (like the rim of a cup or the edge of a tree).

The Result: It ignores the boring, flat parts and focuses its energy on the interesting parts. This stops the computer from wasting time painting dots on empty air.

3. The "Smart Schedule" (Exponential Scale Scheduler)

The Problem: Learning to paint a scene is tricky. If you paint too fast at the beginning, you miss details. If you paint too slow at the end, you never finish.
The Solution: They created a training schedule that acts like a coach.

Phase 1 (The Sprint): At the start, the dots are told to move and grow very fast to cover the whole scene quickly.
Phase 2 (The Marathon): As time goes on, the "speed limit" is gradually lowered. The dots slow down to make tiny, precise adjustments to capture fine details like leaves or brick textures.
The Result: The scene gets built quickly, but then settles down to look incredibly sharp and realistic.

The Results: Faster, Smaller, Better

The authors tested this on a famous set of 3D scenes (Mip-NeRF360). Here is what they found:

Speed: They cut the training time by about 27%. If a scene used to take an hour to build, it now takes about 43 minutes. They saved roughly 17 minutes per scene.
Efficiency: They used 13% fewer dots (Gaussians) to get the same or better picture quality. It's like painting a masterpiece using fewer brushstrokes.
Quality: In some tests, the picture quality (measured by PSNR, a score for clarity) was actually higher than the previous best methods, even though they used fewer resources.

The Bottom Line

ImprovedGS+ is a "low-level" re-engineering of a 3D painting tool. By speaking the computer's native language (C++/CUDA) and using smart, specialized rules for splitting and placing dots, they created a system that is faster, uses less memory, and produces sharper images than the previous best tools. It proves you don't need to throw more resources at a problem; you just need to organize the resources you have much more efficiently.

Technical Summary: ImprovedGS+

Problem Statement

Recent advancements in 3D Gaussian Splatting (3DGS) have necessitated a shift toward balancing reconstruction fidelity with computational efficiency. While existing strategies like ImprovedGS provide robust frameworks for densification, they often rely on high-level Python logic. This reliance creates bottlenecks due to excessive host-device synchronization and multiple memory passes, limiting training throughput and time efficiency. The challenge lies in re-architecting these strategies into a low-level, native implementation that minimizes synchronization overhead without compromising the visual quality required for complex, large-scale environments.

Methodology

The authors propose ImprovedGS+, a high-performance re-implementation of the ImprovedGS strategy, developed natively within the LichtFeld-Studio framework using C++ and CUDA. The methodology transitions from Python-based logic to optimized kernels, focusing on three primary technical innovations:

1. Custom Laplacian-Based Importance Kernels with NMS
To generate precise structural importance maps for densification, the authors replaced high-level framework calls with a distilled, CUDA-native pipeline mimicking Canny Edge Detection logic:

Preprocessing: Grayscale conversion and Gaussian blur (5×5) stored in Constant Memory to filter noise.
Gradient Extraction: Parallel computation of magnitude and orientation using Sobel operators.
Non-Maximum Suppression (NMS): A custom thinning kernel isolates geometric manifolds by comparing magnitudes along the gradient vector.
Result: This approach produces a "thinned structural backbone," preventing "densification drift" by ensuring primitives are placed only on true geometric boundaries, while median-normalization mitigates photometric outliers.

2. Direct CUDA Kernel Long-Axis-Split (LAS)
ImprovedGS+ replaces standard isotropic splitting and cloning with an exclusive Long-Axis-Split (LAS) strategy implemented as a single, specialized CUDA kernel.

Unified Logic: Unlike the original Python implementation which requires multiple memory passes, the entire splitting logic is encapsulated in one kernel, computing geometric and attribute operations in parallel at the individual Gaussian level.
Numerical Consistency: The kernel operates on raw storage data (logarithmic space for scales) to ensure numerical consistency during shrinking operations.
Optimized Transformation: The global coordinate transformation for new Gaussian positions is optimized by extracting the specific column of the rotation matrix corresponding to the principal axis. This reduces the operation from a full 3×3 matrix-vector multiplication (9 multiplications, 6 additions) to a simple linear scaling (3 multiplications).
Algorithm: The split involves shrinking the longest axis by a factor of $\alpha=0.5$ and secondary axes by $\gamma=0.85$ , with opacity reduced by $\beta=0.6$ before converting back to logit space.

3. Adaptive Learning Schedules and Refinement
The authors introduce a two-stage refinement process and modified learning rates to compensate for the removal of Gaussian cloning:

Exponential Scale Scheduler: A learning rate schedule that transitions from a high initial scale rate (0.020) to a final value (0.002) using exponential decay ( $\gamma=0.1$ ). This facilitates rapid volume expansion in Stage I and precision refinement in Stage II.
Positional Learning Rate Optimization: The positional learning rate is significantly increased (initial 0.000128, decaying to 0.0000128) compared to the baseline (0.00004 to 0.000002). This allows for more granular movement and precise placement of primitives.
Global Warm-up Phase: For the first three densification steps (iterations 500, 1000, 1500), gradient-threshold masking is suspended. This allows Gaussians to split based purely on edge scores, ensuring outdoor scenes with broad, low-gradient surfaces are sufficiently populated before strict structural refinement begins.
Fixed Densification Interval: The densification window is constrained to 30 total steps (from iteration 500 to 15,000) to minimize computational overhead.

Key Contributions

Native C++/CUDA Implementation: A complete low-level reinvention of ImprovedGS that eliminates Python overhead, significantly reducing host-device synchronization.
Long-Axis-Split (LAS) Kernel: A custom CUDA kernel that performs splitting, cloning, and global coordinate transformation in a single pass, optimizing memory usage and computational speed.
Enhanced Edge Detection: A custom Laplacian-based importance kernel with NMS that reduces stipple noise on planar surfaces and focuses densification on true geometric boundaries.
Adaptive Scheduling: The introduction of an Exponential Scale Scheduler and optimized positional learning rates that improve initial convergence speed and terminal metrics (PSNR/SSIM).

Experimental Results

Experiments were conducted on the Mip-NeRF360 dataset (9 scenes) using an NVIDIA RTX A4500 GPU, comparing ImprovedGS+ against the MCMC baseline and the ADC strategy.

1M Budget Variant: Compared to the state-of-the-art MCMC baseline, ImprovedGS+ (1M budget) achieved:
- 26.8% reduction in training time (saving 17 minutes per session).
- 13.3% fewer Gaussians utilized.
- Superior visual quality, with a PSNR increase of 0.15 dB (28.79 vs. 28.64) and SSIM increase (0.859 vs. 0.848).
Full Variant: Compared to the ADC baseline, the full ImprovedGS+ variant demonstrated:
- 1.28 dB PSNR increase (29.38 vs. 28.10).
- 38.4% reduction in parametric complexity (1.688M Gaussians vs. 2.741M).
- Training completed in the same temporal window as the MCMC 1M baseline, indicating higher architectural throughput.
Ablation Studies: Removing the Exponential Scale Scheduler resulted in a measurable drop in terminal metrics (e.g., a 0.42 dB PSNR drop in the Bonsai scene), confirming its necessity for stabilizing structural details.

Significance and Claims

The paper claims that ImprovedGS+ establishes a new Pareto-optimal front for scene reconstruction within the LichtFeld-Studio ecosystem. It validates the approach as a scalable, high-speed solution that upholds the core pillars of Speed, Quality, and Usability.

The authors emphasize that their method achieves high-fidelity reconstruction without exhausting maximum permitted budgets (e.g., achieving superior PSNR in the "Room" scene with only 0.591M Gaussians compared to 1.000M for MCMC). The work demonstrates that transitioning from high-level logic to optimized low-level kernels, combined with strategic algorithmic modifications (LAS, adaptive scheduling), can significantly reduce training latency and parametric complexity while maintaining or improving visual fidelity.