Faster-GS: Optimized 3D Gaussian Splatting

• The paper presents Faster-GS, an optimized 3D Gaussian Splatting framework that accelerates training while maintaining high visual quality and nearly constant Gaussian count.
• It retains the canonical 3DGS pipeline—including forward rasterization, loss computation, and backpropagation—while integrating improvements like two-stage radix sorting, opacity-aware truncation, and fused kernels.
• Faster-GS achieves up to a 4.1× speedup and 30% reduced VRAM use over baseline methods, serving as an efficient reference system for both 3D and extended 4D Gaussian reconstructions.

Searching arXiv for the cited Faster-GS paper and closely related Gaussian Splatting acceleration work to ground the article in the current literature. arxiv_search(query="(Hahlbohm et al., 10 Feb 2026) Faster-GS Analyzing and Improving Gaussian Splatting Optimization", max_results=5, sort_by="submittedDate") arxiv_search(query="Faster-GS Analyzing and Improving Gaussian Splatting Optimization", max_results=10, sort_by="submittedDate") Faster-GS is a 3D Gaussian Splatting (3DGS) optimization framework that consolidates implementation-level and algorithmic accelerations into a single training system while preserving the original 3DGS pipeline—forward rasterization, loss computation, backpropagation, parameter update, and densification. Its stated objective is to provide a rigorously optimized algorithm for Gaussian Splatting that is substantially faster, more memory-efficient, and still quality-preserving across standard 3D novel-view-synthesis benchmarks and 4D Gaussian reconstruction settings (Hahlbohm et al., 10 Feb 2026).

1. Scope and position within Gaussian Splatting research

Faster-GS was introduced in response to a fragmented acceleration landscape in which many 3DGS methods combine low-level engineering changes with representation-level or optimization-level changes, making fair comparison difficult. The method therefore emphasizes broadly applicable optimizations and several novel refinements, while explicitly retaining the original 3DGS training structure and standard densification schedule rather than redefining scene growth or changing the terminal Gaussian budget (Hahlbohm et al., 10 Feb 2026).

This positioning distinguishes Faster-GS from several neighboring lines of work. Some methods primarily accelerate optimization by changing the optimizer, such as the Levenberg–Marquardt formulation in "3DGS-LM: Faster Gaussian-Splatting Optimization with Levenberg-Marquardt" (Höllein et al., 2024). Others focus on densification and budget control, such as "Turbo-GS: Accelerating 3D Gaussian Fitting for High-Quality Radiance Fields" (Lu et al., 2024), or on multi-view-consistent densification and pruning, as in "FastGS: Training 3D Gaussian Splatting in 100 Seconds" (Ren et al., 6 Nov 2025). A different family emphasizes rendering-path acceleration, including tensor-core alpha blending in "TC-GS: A Faster Gaussian Splatting Module Utilizing Tensor Cores" (Liao et al., 30 May 2025) and sparse-pixel training in "TurboGS: Accelerating 3D Gaussian Splatting via Error-Guided Sparse Pixel Sampling and Optimization" (Dong et al., 14 Jun 2026). Faster-GS instead acts as a baseline-oriented optimization system whose central claim is that substantial gains can be obtained without changing final quality or Gaussian count (Hahlbohm et al., 10 Feb 2026).

A common misconception is that all faster Gaussian-Splatting pipelines derive their gains from reducing the number of Gaussians or loosening the optimization objective. Faster-GS is explicitly framed against that view: its reported speedups are obtained while maintaining visual quality and keeping the Gaussian count essentially unchanged at convergence (Hahlbohm et al., 10 Feb 2026).

2. Preserved 3DGS formulation

Faster-GS retains the standard 3DGS scene representation: each Gaussian $k$ has a 3D mean $\mu_k \in \mathbb{R}^3$, an anisotropic covariance $\Sigma_k \in \mathbb{R}^{3\times 3}$, a scalar opacity $o_k \in (0,1)$, and 16 spherical-harmonic coefficients per color channel (Hahlbohm et al., 10 Feb 2026).

Rendering follows the standard projection of a 3D Gaussian into screen space:

$$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$

$$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$

with

$$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$

At each pixel $x$, the Gaussian contributes

$$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$

Fragments are approximately depth-sorted and front-to-back alpha-blended according to

$$C = \sum_k \alpha_k\,T_k\,c_k + T_N\,c_{bg}, \qquad T_k = \prod_{j<k}(1-\alpha_j).$$

These equations are not modified by Faster-GS; the method targets the computational bottlenecks induced by repeated rasterization, sorting, blending, and differentiation of millions of Gaussians (Hahlbohm et al., 10 Feb 2026).

The baseline training loop likewise remains recognizable. In the original 3DGS loop, training proceeds for $\mu_k \in \mathbb{R}^3$0 iterations; each iteration samples a training view, projects Gaussians, performs a single 64-bit key/value sort for tile and depth order, rasterizes the image, computes

$\mu_k \in \mathbb{R}^3$1

accumulates gradients by atomic operations, applies Adam, densifies or prunes every $\mu_k \in \mathbb{R}^3$2 iterations, and resets opacity to $\mu_k \in \mathbb{R}^3$3 every $\mu_k \in \mathbb{R}^3$4 iterations (Hahlbohm et al., 10 Feb 2026).

3. Optimization architecture

Faster-GS organizes its contributions into seven categories: numerical-stability refinements; tight, opacity-aware Gaussian truncation and tile culling; two-stage radix sorting; a per-Gaussian backward pass; kernel fusion for activations and spherical-harmonic concatenation; a fused Adam optimizer; and memory coalescence via z-order densification (Hahlbohm et al., 10 Feb 2026).

The numerical-stability component changes the backward treatment of alpha blending. Front-to-back alpha blending in the backward pass eliminates the need for clipping $\mu_k \in \mathbb{R}^3$5 or for division-by-zero workarounds. In addition, degenerate Gaussians with $\mu_k \in \mathbb{R}^3$6 or $\mu_k \in \mathbb{R}^3$7 are dropped during densification (Hahlbohm et al., 10 Feb 2026). This is significant because the paper identifies numerical stability as an underexplored aspect of 3DGS optimization.

The truncation and culling component revisits one of the most performance-critical geometric heuristics in 3DGS. The original Kerbl-style truncation uses $\mu_k \in \mathbb{R}^3$8, which couples the truncation radius to opacity. Faster-GS instead first checks

$\mu_k \in \mathbb{R}^3$9

before multiplying by $\Sigma_k \in \mathbb{R}^{3\times 3}$0, thereby enabling opacity-independent truncation at a chosen $\Sigma_k \in \mathbb{R}^{3\times 3}$1-multiple. For an axis-aligned $\Sigma_k \in \mathbb{R}^{3\times 3}$2, the half-extents become

$\Sigma_k \in \mathbb{R}^{3\times 3}$3

with $\Sigma_k \in \mathbb{R}^{3\times 3}$4 chosen, for example, as $\Sigma_k \in \mathbb{R}^{3\times 3}$5, $\Sigma_k \in \mathbb{R}^{3\times 3}$6, or $\Sigma_k \in \mathbb{R}^{3\times 3}$7 to trade compute against Gaussian count (Hahlbohm et al., 10 Feb 2026).

A related change is the opacity-aware axis-aligned bound:

$\Sigma_k \in \mathbb{R}^{3\times 3}$8

which replaces a fixed $\Sigma_k \in \mathbb{R}^{3\times 3}$9 square by a rectangle whose extent depends on opacity. This reduces the number of overlapped tiles when $o_k \in (0,1)$0. Faster-GS then combines this bound with load-balanced, tile-based ellipse culling, which is described as eliminating false positives while balancing warp work (Hahlbohm et al., 10 Feb 2026).

The sorting stage is restructured from a single 64-bit key sort into a two-stage radix sort. The baseline cost is given as approximately $o_k \in (0,1)$1. Faster-GS performs a 32-bit depth radix sort with cost $o_k \in (0,1)$2, followed by a 16-bit tile radix sort on compacted lists with cost $o_k \in (0,1)$3, yielding a total of approximately $o_k \in (0,1)$4 instead of $o_k \in (0,1)$5 (Hahlbohm et al., 10 Feb 2026). This change is central because sorting is one of the dominant costs in 3DGS training.

The backward pass is also reworked. Instead of pixel-parallel atomic accumulation, Faster-GS launches one warp per 32-Gaussian bucket. Each thread accumulates $o_k \in (0,1)$6 for its Gaussian across a $o_k \in (0,1)$7 tile using stored intermediate states, and shared memory is used to load $o_k \in (0,1)$8 and $o_k \in (0,1)$9 in coalesced blocks, which is reported to halve global-load stalls (Hahlbohm et al., 10 Feb 2026).

Kernel fusion further reduces overhead. Faster-GS concatenates view-independent and view-dependent spherical-harmonic buffers on the fly inside the rasterizer and fuses activation functions for scale, rotation, and opacity into the forward kernel, generating their gradients directly in the backward pass (Hahlbohm et al., 10 Feb 2026).

Finally, the parameter-update stage is moved into a fused CUDA Adam kernel:

$$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$0

$$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$1

This reduces parameter-update overhead by up to $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$2. Complementing it, Faster-GS periodically reorders Gaussians by Morton, or z-order, code every $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$3 iterations, improving spatial memory locality and reducing cache misses and warp divergence during rasterization and backward computation (Hahlbohm et al., 10 Feb 2026).

4. Training loop and computational profile

The Faster-GS training loop preserves the same supervision and scene-growth schedule as baseline 3DGS, but the internal execution path is modified at nearly every performance-sensitive stage. Each iteration samples a view, projects Gaussians using fused activations, computes the opacity-aware AABB, applies load-balanced tile culling, executes the two-stage radix sort, rasterizes and forward-blends the image, computes the same loss, performs the per-Gaussian backward pass with shared-memory buckets, and applies the fused Adam update while skipping parameters with zero gradient. Standard densification remains at every $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$4 iterations, opacity reset remains at every $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$5 iterations, and z-order reordering is inserted every $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$6 iterations (Hahlbohm et al., 10 Feb 2026).

The paper’s complexity discussion presents the method as a reduction in constant factors rather than a change of asymptotic training structure. With $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$7 Gaussians, average tile overlap $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$8, and $$\mu_{2D} = (f_x \hat{x}/\hat{z} + c_x,\; f_y \hat{y}/\hat{z} + c_y)^\top,$$9 pixels per tile, baseline 3DGS has projection and instancing cost $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$0, a single radix sort of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$1, rasterization and forward blending of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$2, pixel-parallel atomic backward work of similar order, and an $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$3 Adam update. The summarized total is approximately $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$4 per iteration (Hahlbohm et al., 10 Feb 2026).

Faster-GS changes that accounting to projection plus fused activations of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$5, AABB and culling of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$6, two-stage sort of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$7, forward rasterization of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$8, per-Gaussian backward of $$\Sigma_{2D} = J\,W_{1:3,1:3}\,\Sigma\,W_{1:3,1:3}^\top J^\top,$$9 with fewer atomics, and fused Adam plus z-order reordering of $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$0. The paper summarizes the resulting total as approximately $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$1 per iteration, corresponding to a reported $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$2 to $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$3 reduction in sort, blend, and backward overhead, together with roughly $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$4 lower VRAM use through 32-bit sorts, compact buffers, the absence of separate alpha maps, and the fused optimizer (Hahlbohm et al., 10 Feb 2026).

This suggests that Faster-GS is best understood as a systems-level optimization of the canonical 3DGS execution graph. A plausible implication is that its reported gains are particularly relevant when the primary bottlenecks are memory traffic, sorting bandwidth, and gradient accumulation overhead rather than deficient convergence behavior of the optimizer itself.

5. Benchmark behavior

On the combined benchmark of 13 scenes from Mip-NeRF360, Tanks & Temples, and Deep Blending, the paper reports the following average results on an RTX 4090 (Hahlbohm et al., 10 Feb 2026):

Method	Quality	Train time / VRAM
Baseline 3DGS	27.53 PSNR, 0.815 SSIM	18 m 44 s, 8.8 GiB
Basis Impl. (ours)	27.57 PSNR, 0.816 SSIM	15 m 57 s, 6.3 GiB
Faster-GS (full)	27.56 PSNR, 0.816 SSIM	4 m 31 s, 6.1 GiB

The full system is reported to achieve a $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$5 speedup over baseline 3DGS and $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$6 over Taming-3DGS, with no PSNR or SSIM loss and essentially unchanged final Gaussian count: $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$7 million for Faster-GS versus $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$8 million for baseline 3DGS (Hahlbohm et al., 10 Feb 2026). These numbers are consistent with the paper’s higher-level claim of up to $$J = \begin{bmatrix} f_x/\hat{z} & 0 & -f_x \hat{x}/\hat{z}^2 \ 0 & f_y/\hat{z} & -f_y \hat{y}/\hat{z}^2 \end{bmatrix}.$$9 faster training and $x$0 less VRAM without altering final quality or Gaussian count.

The comparison to the intermediate “Basis Impl. (ours)” is also informative. The basis implementation already improves over baseline 3DGS while preserving quality, indicating that a portion of the gains derives from a cleaner or more optimized baseline. The full Faster-GS stack then compounds those savings through its full set of fused kernels, new sorting pipeline, backward redesign, and memory-layout optimization (Hahlbohm et al., 10 Feb 2026).

An important point is that the reported quality preservation is not merely qualitative. The average PSNR changes from $x$1 to $x$2, SSIM from $x$3 to $x$4, and the number of Gaussians remains effectively constant. In the context of 3DGS acceleration, this distinguishes Faster-GS from methods whose gains depend on training for fewer steps, adding fewer primitives, or accepting measurable fidelity trade-offs.

6. Extension to 4D Gaussian reconstruction and broader significance

Faster-GS is not restricted to static 3D scenes. The paper extends the same optimization stack to 4D Gaussian reconstruction by augmenting the representation with a temporal mean $x$5, a temporal scale $x$6, and two quaternions for isoclinic rotations. At time $x$7, the conditioned 4D Gaussian becomes a 3D Gaussian with

$x$8

$x$9

and the temporal marginal

$$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$0

rescales opacity as $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$1 (Hahlbohm et al., 10 Feb 2026).

On D-NeRF synthetic scenes, the reported comparison is $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$2 PSNR, $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$3 m $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$4 s, $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$5 GiB, and $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$6 million Gaussians for Yang et al. (4DGS), versus $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$7 PSNR, $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$8 m $$\alpha = o \cdot \exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right].$$9 s, $$C = \sum_k \alpha_k\,T_k\,c_k + T_N\,c_{bg}, \qquad T_k = \prod_{j<k}(1-\alpha_j).$$0 GiB, and $$C = \sum_k \alpha_k\,T_k\,c_k + T_N\,c_{bg}, \qquad T_k = \prod_{j<k}(1-\alpha_j).$$1 million Gaussians for Faster-GS (4D ext.) (Hahlbohm et al., 10 Feb 2026). The paper summarizes this as a $$C = \sum_k \alpha_k\,T_k\,c_k + T_N\,c_{bg}, \qquad T_k = \prod_{j<k}(1-\alpha_j).$$2 speedup, identical image quality, and $$C = \sum_k \alpha_k\,T_k\,c_k + T_N\,c_{bg}, \qquad T_k = \prod_{j<k}(1-\alpha_j).$$3 less VRAM. This extension is noteworthy because it indicates that the paper’s low-level and mid-level optimizations are not confined to the static 3D case.

In the broader literature, Faster-GS occupies the role of a resource-efficient reference system rather than a narrowly specialized accelerator. Optimizer-centric approaches such as 3DGS-LM (Höllein et al., 2024), densification-centric approaches such as Turbo-GS (Lu et al., 2024), balancing-and-pruning approaches such as Trick-GS (Armagan et al., 24 Jan 2025), tensor-core rendering modules such as TC-GS (Liao et al., 30 May 2025), and sparse-supervision pipelines such as TurboGS (Dong et al., 14 Jun 2026) all attack different segments of the 3DGS pipeline. Faster-GS instead argues that a substantial portion of the remaining cost can be removed by rigorously optimizing the canonical pipeline itself (Hahlbohm et al., 10 Feb 2026).

This suggests two broader implications. First, benchmark comparisons among Gaussian-Splatting accelerators require careful separation of algorithmic changes from systems-engineering changes. Second, the paper’s results support the view that implementation details—sorting precision, culling policy, memory layout, activation fusion, and backward accumulation strategy—are not peripheral in 3DGS; they are central determinants of wall-clock performance and VRAM footprint (Hahlbohm et al., 10 Feb 2026).