FilterGS: Efficient LoD 3D Gaussian Splatting

• FilterGS is a large-scale LoD 3D Gaussian Splatting acceleration framework that replaces serial Gaussian-tree traversal with traversal-free parallel filtering.
• It integrates complementary filters—the RL Filter and Ancestor Filter—with a GTC-guided Gaussian shrinking strategy to eliminate redundant Gaussian–tile processing.
• The method achieves state-of-the-art rendering speeds while reducing preprocessing overhead and maintaining competitive visual quality.

FilterGS is a large-scale Level-of-Detail (LoD) 3D Gaussian Splatting acceleration framework that replaces serial Gaussian-tree traversal with traversal-free parallel filtering and reduces redundant Gaussian–tile processing through scene-adaptive Gaussian shrinking. It was introduced to address two front-end bottlenecks in large-scene LoD rendering: serial hierarchy traversal and redundant Gaussian–tile key-value pairs. In some scenes, traversal and filtering alone consume over $60\%$ of rendering time, and many Gaussian–tile pairs contribute negligibly to the final image while still incurring preprocessing, sorting, and rasterization overhead. FilterGS combines two complementary filters—$R_L$ Filter and Ancestor Filter—with a GTC-guided shrinking strategy, and is reported to achieve state-of-the-art rendering speeds while maintaining competitive visual quality on multiple large-scale datasets (Wang et al., 25 Mar 2026).

1. Problem formulation in large-scale LoD 3D Gaussian Splatting

Large-scale 3D scenes require many Gaussians to preserve detail, but direct rendering is too expensive. LoD methods mitigate this by storing Gaussians in a hierarchy and selecting only a subset for the current view. FilterGS was proposed because prior LoD systems such as H3DGS, FLoD, LoG, and OctreeGS still spend substantial time in two places: serial hierarchy traversal and redundant Gaussian–tile processing (Wang et al., 25 Mar 2026).

The first bottleneck is structural. Traditional LoD pipelines inspect the Gaussian tree level by level, which induces repeated GPU kernel launches and synchronization overhead. The second bottleneck is compositional. Even when some Gaussians barely affect the image, they still generate Gaussian–tile key-value pairs that must be sorted and blended. FilterGS targets both bottlenecks simultaneously: it changes how Gaussians are selected from the hierarchy and how redundant projected support is pruned before later rendering stages.

The method is therefore not a generic denoising or image-space filter. It is a rendering acceleration framework whose filtering acts on LoD selection and projected Gaussian support. A plausible implication is that FilterGS should be understood primarily as a front-end efficiency method for large-scene 3DGS, rather than as a modification of the radiance or appearance model itself.

2. Traversal-free parallel filtering

The core selection mechanism replaces level-by-level tree traversal with two complementary filters executed in parallel: the $R_L$ Filter and the Ancestor Filter (Wang et al., 25 Mar 2026).

For each in-frustum Gaussian, FilterGS projects it to 2D and computes its screen-space covariance $\Sigma_{2D}$. Let $\sigma$ denote the standard deviations along the principal axes. The pixel radius is defined as

$R_{2D} = 3\sigma.$

A Gaussian node is retained if

$R_{2D} \le \tau_R,$

where the radius threshold $\tau_R$ is set to $3$. This is the $R_L$ Filter. Its role is to retain projected Gaussians that are already small enough in screen space to serve as adequate LoD representatives. However, a pure radius rule could eliminate entire branches if all internal nodes remain too large. To avoid holes, all leaf nodes are preserved at least once.

That provisional selection introduces another redundancy: multiple nodes on the same branch may survive. The Ancestor Filter removes this overlap. Let $R_L$0 be the $R_L$1-th node at level $R_L$2, and let $R_L$3 denote its ancestor path, i.e., the ordered list of ancestor node IDs from parent to root. If an internal node $R_L$4 passes the radius test, then every descendant $R_L$5 satisfying

$R_L$6

is culled, including leaves that were provisionally retained. The effective policy is therefore to keep the highest-level valid node on each branch, but without serial traversal.

The speedup comes from removing tree-depth dependence from the filtering stage. The paper contrasts a serial cost of

$R_L$7

with a unified parallel cost

$R_L$8

where $R_L$9 is tree depth, $R_L$0 is the number of nodes at level $R_L$1, and $R_L$2 is the total number of in-frustum Gaussians. All levels are processed together in a single CUDA kernel, which removes repeated synchronization, improves GPU occupancy, exploits SIMD and memory coalescing, and scales better to tens of millions of Gaussians.

3. Scene-adaptive Gaussian shrinking and redundancy metrics

FilterGS complements parallel selection with a second mechanism aimed at projected redundancy: scene-adaptive Gaussian shrinking. The objective is to reduce redundant Gaussian–tile key-value pairs before sorting and alpha blending (Wang et al., 25 Mar 2026).

The method first defines Key-value Pair Contribution (KPC) for a Gaussian $R_L$3 and tile $R_L$4: $R_L$5 where $R_L$6 is the number of pixels in the tile, $R_L$7 is the opacity of Gaussian $R_L$8 at pixel $R_L$9, and $\Sigma_{2D}$0 is the residual transmittance before $\Sigma_{2D}$1 at pixel $\Sigma_{2D}$2. KPC approximates the effective number of pixels influenced by a Gaussian inside the tile. Pairs with

$\Sigma_{2D}$3

are treated as redundant.

To move from pair-level redundancy to scene-level adaptation, the paper introduces Gaussian to Tile Contribution (GTC): $\Sigma_{2D}$4 where $\Sigma_{2D}$5 is the number of Gaussians affecting tile $\Sigma_{2D}$6. A view-level mean is then computed as

$\Sigma_{2D}$7

and the scene-level average over all images is

$\Sigma_{2D}$8

GTC is explicitly used to distinguish two cases that superficially look similar: true redundancy caused by many weak Gaussians overcrowding a tile, and genuinely semi-transparent structure such as foliage or fences, where many low-opacity Gaussians may still be necessary. A low $\Sigma_{2D}$9 indicates severe congestion and motivates more aggressive shrinking.

Instead of using a fixed opacity threshold, FilterGS defines the shrinking threshold adaptively as

$\sigma$0

where $\sigma$1 controls aggressiveness. The effective shrinking radius is obtained from the opacity decay relation

$\sigma$2

where $\sigma$3 is the largest standard-deviation axis and $\sigma$4 is the central opacity. If the scene is congested, $\sigma$5 becomes low, $\sigma$6 becomes larger, and shrinking becomes more aggressive. This is the sense in which the method is scene-adaptive.

4. Experimental profile and quantitative behavior

FilterGS is evaluated on three large-scale datasets: MatrixCity, GauUScene, and UrbanScene, with camera poses estimated by COLMAP (Wang et al., 25 Mar 2026). The MatrixCity evaluation uses the Block Small subset, containing 5,620 images over an area of about $\sigma$7. GauUScene includes College, Residence, and Modern-Building. UrbanScene includes Residence and Sci-Art. Reported metrics are PSNR, SSIM, LPIPS, filtering time $\sigma$8 in milliseconds, and FPS.

The method achieves the best FPS across all reported scenes. Representative values are:

Scene	FPS
Block Small	372
Sci-Art	234
Residence (UrbanScene)	297
College	290
Modern-Building	354

These speeds are substantially higher than the reported ranges for prior LoD methods in the same experiments: LoG at 66–77 FPS, OctreeGS at 83–125 FPS, and FLoD at 147–245 FPS. The paper further states that parallel filtering boosts rendering FPS by over $\sigma$9, while the shrinking strategy contributes another over $R_{2D} = 3\sigma.$0 FPS improvement. Filtering time is reduced by over $R_{2D} = 3\sigma.$1, and synchronization time is reduced by $R_{2D} = 3\sigma.$2.

The quality trade-off is explicitly quantified. FilterGS keeps reconstruction quality competitive with the best LoD methods, often matching or approaching the top PSNR and SSIM values while being much faster. The shrinking strategy introduces about a $R_{2D} = 3\sigma.$3 PSNR drop in exchange for around $R_{2D} = 3\sigma.$4 FPS gain. The paper treats this as a favorable trade-off for real-time applications.

The redundancy analysis is equally central. The shrinking strategy prunes an additional $R_{2D} = 3\sigma.$5 of remaining redundant key-value pairs for FilterGS, compared with $R_{2D} = 3\sigma.$6 for vanilla 3DGS. On College and Modern-Building, FilterGS with $R_{2D} = 3\sigma.$7 reduces the number of pairs $R_{2D} = 3\sigma.$8 to $R_{2D} = 3\sigma.$9 and $R_{2D} \le \tau_R,$0, respectively. Ablation results indicate that the parallel filter provides the major runtime reduction, while shrinking primarily reduces sorting and alpha blending cost; the two are therefore complementary rather than interchangeable.

5. Position within the broader 3DGS filtering and acceleration landscape

FilterGS belongs to a broader family of 3DGS methods that use “filtering” to address different failure modes, but its target is specifically large-scene LoD acceleration. In that respect it differs from methods whose filtering objective is anti-aliasing, out-of-distribution stabilization, or arithmetic acceleration.

Mipmap-GS, for example, is a test-time, scale-adaptive filtering method that adapts Gaussian primitives themselves to arbitrary zoom factors using pseudo ground-truth and a scale-consistency guidance loss. It addresses zoom-in and zoom-out aliasing caused by sampling-rate mismatch, not hierarchy traversal or Gaussian–tile redundancy (Li et al., 2024). Extreme Views: 3DGS Filter addresses another distinct problem: render-time filtering for camera poses far outside the training distribution. Its mechanism is a two-pass, view-conditioned suppression of unstable Gaussians based on sensitivity scores derived from intermediate gradients, with explicit emphasis on anisotropic orientation instability (Bowness et al., 22 Oct 2025).

Within acceleration research, GEMM-GS is especially relevant because it clarifies the complementary role of filtering-based methods. GEMM-GS does not reduce workload via culling, pruning, or skipping redundant Gaussians or pixels. Instead, it reformulates the blending stage into a GEMM-compatible form for Tensor Core execution. The paper explicitly characterizes this as orthogonal to filtering-style acceleration: filtering reduces the amount of work, while GEMM-GS accelerates the blending of the work that remains (Li et al., 2 Apr 2026).

This suggests that “filtering” in contemporary 3DGS research denotes several technically distinct operations. In FilterGS, filtering means traversal-free LoD selection plus projected-support reduction. In Mipmap-GS, it denotes scale-consistent adaptation of Gaussian primitives. In Extreme Views, it denotes render-time suppression of unstable view-conditioned contributions. The shared term masks substantially different objectives, optimization variables, and runtime locations in the rendering pipeline.

6. Limitations, costs, and significance

FilterGS introduces a manageable memory overhead from ancestor-path indexing: around $R_{2D} \le \tau_R,$1 extra memory compared to the original tree structure (Wang et al., 25 Mar 2026). The method also accepts a small quality loss when adaptive shrinking is enabled, quantified as about a $R_{2D} \le \tau_R,$2 PSNR drop for around $R_{2D} \le \tau_R,$3 FPS gain. These are not incidental details; they delimit the operating regime in which the method is intended to be useful.

A further limitation is implicit in the design of the shrinking rule. Because shrinking aggressiveness depends on $R_{2D} \le \tau_R,$4 and on the estimated scene-level congestion $R_{2D} \le \tau_R,$5, the method assumes that redundancy can be profitably summarized by GTC. The paper motivates this by distinguishing congestion from legitimate semi-transparent structure, but it does not claim that shrinking is free of trade-offs. The ablation results reinforce that the major runtime gain comes from traversal-free filtering, while shrinking is a secondary but still meaningful complement.

The significance of FilterGS lies in where it places the main optimization effort. Rather than only accelerating blending or compressing the Gaussian set, it treats LoD rendering efficiency as a selection-and-support problem. The method’s central claim is that rendering efficiency is limited not just by how many Gaussians exist, but by how they are selected and how many unnecessary Gaussian–tile pairs are generated. On the reported benchmarks, this reframing yields rendering in the hundreds of frames per second while maintaining competitive visual quality (Wang et al., 25 Mar 2026).