---
title: 'Faster-GS: Optimized 3D Gaussian Splatting'
url: https://www.emergentmind.com/topics/faster-gs
type: topic
---

# Faster-GS: Optimized 3D Gaussian Splatting

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="2602.09999 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 [2602.09999].

## 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 [2602.09999].

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" [2409.12892]. Others focus on densification and budget control, such as "Turbo-GS: Accelerating 3D Gaussian Fitting for High-Quality Radiance Fields" [2412.13547], or on multi-view-consistent densification and pruning, as in "FastGS: Training 3D Gaussian Splatting in 100 Seconds" [2511.04283]. A different family emphasizes rendering-path acceleration, including tensor-core alpha blending in "TC-GS: A Faster Gaussian Splatting Module Utilizing Tensor Cores" [2505.24796] and sparse-pixel training in "TurboGS: Accelerating 3D Gaussian Splatting via Error-Guided Sparse Pixel Sampling and Optimization" [2606.15924]. 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 [2602.09999].

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 [2602.09999].

## 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 [2602.09999].

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 [2602.09999].

The baseline training loop likewise remains recognizable. In the original 3DGS loop, training proceeds for \(30\,000\) 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
$$
\mathcal{L} = 0.8\,\|C-C_{gt}\|_1 + 0.2\,DSSIM(C,C_{gt}),
$$
accumulates gradients by atomic operations, applies Adam, densifies or prunes every \(100\) iterations, and resets opacity to \(0.01\) every \(3\,000\) iterations [2602.09999].

## 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 [2602.09999].

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 \(\alpha < 0.99\) or for division-by-zero workarounds. In addition, degenerate Gaussians with \(\|q\|<10^{-4}\) or \(\det(\Sigma_{2D})<10^{-6}\) are dropped during densification [2602.09999]. 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 \(\alpha < \tau_\alpha = 1/255\), which couples the truncation radius to opacity. Faster-GS instead first checks
$$
\exp\!\left[-\tfrac12 (x-\mu_{2D})^\top \Sigma_{2D}^{-1}(x-\mu_{2D})\right] < \tau_\alpha
$$
before multiplying by \(o\), thereby enabling opacity-independent truncation at a chosen \(\sigma\)-multiple. For an axis-aligned \(\Sigma_{2D}\), the half-extents become
$$
\Delta_i = \sqrt{\Sigma_{2D,ii}} \cdot k_{\rm trunc},
$$
with \(k_{\rm trunc}\) chosen, for example, as \(3.0\), \(2.0\), or \(1.0\) to trade compute against Gaussian count [2602.09999].

A related change is the opacity-aware axis-aligned bound:
$$
w_i = \sqrt{-2\ln(\tau_\alpha/o)\cdot \Sigma_{2D,ii}},
$$
which replaces a fixed \(6\sigma\) square by a rectangle whose extent depends on opacity. This reduces the number of overlapped tiles when \(o<1\). Faster-GS then combines this bound with load-balanced, tile-based ellipse culling, which is described as eliminating false positives while balancing warp work [2602.09999].

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(8\cdot 48 \cdot N)\). Faster-GS performs a 32-bit depth radix sort with cost \(O(1\cdot 32\cdot N)\), followed by a 16-bit tile radix sort on compacted lists with cost \(O(8\cdot 16\cdot N)\), yielding a total of approximately \(O(160N)\) instead of \(O(384N)\) [2602.09999]. 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 \(\partial L/\partial \theta_k\) for its Gaussian across a \(16\times 16\) tile using stored intermediate states, and shared memory is used to load \(\alpha\) and \(T\) in coalesced blocks, which is reported to halve global-load stalls [2602.09999].

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 [2602.09999].

Finally, the parameter-update stage is moved into a fused CUDA Adam kernel:
$$
m \leftarrow \beta_1 m + (1-\beta_1)g,
\qquad
v \leftarrow \beta_2 v + (1-\beta_2)g^2,
$$
$$
\theta \leftarrow \theta - \eta\,\hat{m}/(\sqrt{\hat{v}}+\epsilon).
$$
This reduces parameter-update overhead by up to \(30\%\). Complementing it, Faster-GS periodically reorders Gaussians by Morton, or z-order, code every \(5\,000\) iterations, improving spatial memory locality and reducing cache misses and warp divergence during rasterization and backward computation [2602.09999].

## 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 \(100\) iterations, opacity reset remains at every \(3\,000\) iterations, and z-order reordering is inserted every \(5\,000\) iterations [2602.09999].

The paper’s complexity discussion presents the method as a reduction in constant factors rather than a change of asymptotic training structure. With \(N\) Gaussians, average tile overlap \(T\approx 8\), and \(P=256\) pixels per tile, baseline 3DGS has projection and instancing cost \(O(N)\), a single radix sort of \(O(T\cdot 48\cdot N)\), rasterization and forward blending of \(O(T\cdot P\cdot C)\), pixel-parallel atomic backward work of similar order, and an \(O(N)\) Adam update. The summarized total is approximately \(O(384N + TP)\) per iteration [2602.09999].

Faster-GS changes that accounting to projection plus fused activations of \(O(N)\), AABB and culling of \(O(T\cdot 1\cdot N)\), two-stage sort of \(O(32N + 16T\cdot N)=O(160N)\), forward rasterization of \(O(T\cdot P)\), per-Gaussian backward of \(O(T\cdot C\cdot N/32)\) with fewer atomics, and fused Adam plus z-order reordering of \(O(N)\). The paper summarizes the resulting total as approximately \(O(160N + N + TP)\) per iteration, corresponding to a reported \(1.5\times\) to \(2.5\times\) reduction in sort, blend, and backward overhead, together with roughly \(30\%\) lower VRAM use through 32-bit sorts, compact buffers, the absence of separate alpha maps, and the fused optimizer [2602.09999].

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 [2602.09999]:

| 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 \(4.1\times\) speedup over baseline 3DGS and \(2.4\times\) over Taming-3DGS, with no PSNR or SSIM loss and essentially unchanged final Gaussian count: \(2.73\) million for Faster-GS versus \(2.74\) million for baseline 3DGS [2602.09999]. These numbers are consistent with the paper’s higher-level claim of up to \(5\times\) faster training and \(30\%\) 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 [2602.09999].

An important point is that the reported quality preservation is not merely qualitative. The average PSNR changes from \(27.53\) to \(27.56\), SSIM from \(0.815\) to \(0.816\), 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 \(\mu_4\), a temporal scale \(\Sigma_{4,4}\), and two quaternions for isoclinic rotations. At time \(t\), the conditioned 4D Gaussian becomes a 3D Gaussian with
$$
\mu_{3D|t} = \mu_{1:3} + \Sigma_{1:3,4}\Sigma_{4,4}^{-1}(t-\mu_4),
$$
$$
\Sigma_{3D|t} = \Sigma_{1:3,1:3} - \Sigma_{1:3,4}\Sigma_{4,4}^{-1}\Sigma_{4,1:3},
$$
and the temporal marginal
$$
p(t)=\mathcal{N}(t;\mu_4,\Sigma_{4,4})
$$
rescales opacity as \(\alpha \rightarrow \alpha \cdot p(t)\) [2602.09999].

On D-NeRF synthetic scenes, the reported comparison is \(31.52\) PSNR, \(18\) m \(09\) s, \(1.9\) GiB, and \(0.83\) million Gaussians for Yang et al. (4DGS), versus \(31.79\) PSNR, \(6\) m \(22\) s, \(1.2\) GiB, and \(0.79\) million Gaussians for Faster-GS (4D ext.) [2602.09999]. The paper summarizes this as a \(2.8\times\) speedup, identical image quality, and \(37\%\) 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 [2409.12892], densification-centric approaches such as Turbo-GS [2412.13547], balancing-and-pruning approaches such as Trick-GS [2501.14534], tensor-core rendering modules such as TC-GS [2505.24796], and sparse-supervision pipelines such as TurboGS [2606.15924] 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 [2602.09999].

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 [2602.09999].

Source: https://www.emergentmind.com/topics/faster-gs