3D Gaussian Splatting has revolutionized neural rendering with real-time performance. However, scaling this approach to large scenes using Level-of-Detail methods faces critical challenges: inefficient serial traversal consuming over 60% of rendering time, and redundant Gaussian-tile pairs that incur unnecessary processing overhead. To address these limitations, we introduce FilterGS, featuring a parallel filtering mechanism with two complementary filters that select Gaussian elements efficiently without tree traversal. Additionally, we propose a novel GTC metric that quantifies the redundancy of Gaussian-tile key-value pairs. Based on this metric, we introduce a scene-adaptive Gaussian shrinking strategy that effectively reduces redundant pairs. Extensive experiments demonstrate that FilterGS achieves state-of-the-art rendering speeds while maintaining competitive visual quality across multiple large-scale datasets. Project page: https://github.com/xenon-w/FilterGS
Figures & tables
Figure 2: The framework of FilterGS . (a) Given a set of images and SfM points for a large-scale scene, we first train a LoD-GS tree model. (Sec. 3.1 ) (b) To quantify redundancy of scene-wide Gaussian-tile pairs, we perform a pre-rendering pass over all training views. While following the standard 3DGS pipeline, this stage computes the GTC metric Gˉ and derives a shrinking threshold τ=f(Gˉ) . (Sec. 3.3 ) (c) In the formal rendering stage, the pre-computed scaling factor τ and the tree model are processed by two specialized filters to efficiently select Gaussians for rendering. These Gaussians are adaptively scaled by τ during AABB formation, significantly reducing redundant key-value pairs before final sorting and α -blending. (Sec. 3.2 )
Figure 3: Comparison of serial and parallel filtering strategies. LoG starts from level=0 and progressively applies R&C rules to filter internal nodes with oversized 2D radii and child nodes, retaining only leaves or sufficiently small internal nodes. In contrast, FilterGS simultaneously applies the R&L Filter across all levels to preserve nodes with small 2D radii and all leaf nodes, while introducing an Ancestor Filter to exclude nodes whose ancestor paths contain qualified internal nodes. This yields a key advantage: while LoG’s serial filtering requires steps proportional to tree depth (more levels, more steps), FilterGS completes parallel filtering in just two steps (No more levels, no matter levels).
Figure 4: Schematic Diagram of the Progressive Relationship Between the Four Core Formulas (Eqa. 5 , 6 , 7 , 8 ) of Sec. 3.3 .
Method
Block Small [ 12 ]
Sci-Art [ 15 ]
Residence [ 15 ]
PSNR ↑
SSIM ↑
LPIPS ↓
tf↓
FPS ↑
PSNR ↑
SSIM ↑
LPIPS ↓
tf↓
FPS ↑
PSNR ↑
SSIM ↑
LPIPS ↓
tf↓
FPS ↑
3DGS
25.42
0.743
0.446
–
58.0
22.35
0.717
0.311
–
61.0
21.92
0.767
0.298
–
62.0
H3DGS
25.73
0.756
0.440
5.51
83.0
22.41
0.719
0.312
53.46
72.0
21.99
0.769
0.294
7.12
38.0
LoG
26.52
0.770
0.414
10.46
77.0
23.27
0.737
0.305
11.6
67.0
22.7
0.812
0.267
11.33
66.0
OctreeGS
26.43
0.771
0.417
5.13
125.0
23.81
0.758
0.295
6.78
83.0
22.31
0.793
0.279
5.58
91.0
Table 1: Quantitative results on MatrixCity [ 12 ] , UrbanScene [ 15 ] and GauUScene [ 32 ] dataset. The 1st , 2nd and 3rd best results are highlighted. Our method achieves state-of-the-art rendering FPS by reducing filter time tf (ms) and employing the Gaussian shrinking strategy, maintaining high-fidelity reconstruction quality competitive with the top-performing approaches.
Figure 5: Comparison of Different Shrinking Strategy on College and Modern-Building [ 32 ] . The best results are highlighted in bold . NP represents the total number of generated key-value pairs. (a) to (d) show the rendered detail: (a) vanilla 3DGS ( 3σ principle); (b) 3DGS with our shrinking strategy ( λG=0.2 ); (c) FilterGS with the 3σ principle; (d) FilterGS with λG=0.2 .
Shrink
Filter
Tcalcu.
Tsynch.
Tprepr.
Tsort
Talpha
Ttotal
FPS
✗
✗
3.59
7.72
0.20
1.04
2.58
15.13
66
✓
✗
3.59
7.80
0.27
0.61
1.69
13.96
72
✗
✓
0.52
0.41
0.19
1.01
2.64
4.77
210
✓
✓
0.52
0.40
0.26
0.57
1.62
3.37
297
Table 2: Ablation Study about Rendering Time Cost (ms) on Residence [ 15 ] . The best results are highlighted in bold . The total rendering time ( Ttotal ) is divided into four phases: Gaussian filtering ( Tcalcu.+Tsynch. ), preprocessing ( Tprepr. ), sorting ( Tsort ), and α -blending ( Talpha ).
College
Modern
Shrink
Filter
PSNR
SSIM
NP↓
PSNR
SSIM
NP↓
✗
✗
25.90
0.752
3.25M
27.35
0.813
2.13M
✓
✗
25.69
0.748
1.56M
27.04
0.810
1.12M
✗
✓
25.90
0.752
3.25M
27.35
0.813
2.13M
✓
✓
25.69
0.748
1.56M
27.04
0.810
1.12M
Table 3: Ablation Study about Rendering Quality on College [ 32 ] and Modern-Building [ 32 ] . NP represents the total number of generated key-value pairs.
Figure 6: (a). The Trade-off between PSNR and FPS versus λG . (b). Distribution of Key-Value Pairs as a Function of KPC, with (w/) and without (w/o) the shrinking. ( λG=0.2 , scene: Residence [ 15 ] )
Figure 7: Effect of λG on Key-Value Pair Pruning and Rendering Detail on Block [ 12 ] and Residence [ 32 ] . Nlow represents the number (M) of KPC <0.01 pairs.
We present BlitzGS, a distributed 3DGS framework that reduces active Gaussian workload for fast city-scale reconstruction. BlitzGS manages this workload at three coupled levels. At the system level, the framework shards Gaussians across GPUs by index parity rather than spatial blocks. This approach mitigates the cross-block visibility redundancy inherent in spatial partitioning. Furthermore, it distributes each rendering step through a single cross-GPU exchange that routes projected Gaussians to their tile owners. At the model level, scheduled importance-scoring passes shrink the global Gaussian population. During these passes, the framework generates a per-Gaussian visibility weight to bias density-control updates toward contributing primitives and a per-view importance mask for the view-level renderer. At the view level, BlitzGS trims each camera's active set with a distance-based LOD gate to exclude excessively fine primitives for the current frustum and the importance-based culling mask to skip Gaussians with negligible cross-view contribution. On large-scale benchmarks, BlitzGS matches the rendering quality of recent large-scale baselines while delivering an order-of-magnitude speedup, training city-scale scenes in tens of minutes. Our code is available at https: //github.com/AkierRaee/BlitzGS.
3D Gaussian Splatting (3DGS) enables real-time novel view synthesis, but existing general-purpose acceleration methods suffer severe rendering quality degradation when extended to more complex, large-scale scenes. To address this issue, we propose EffGS, a more general acceleration framework that improves training and rendering efficiency while maintaining reconstruction quality comparable to or better than vanilla 3DGS across bounded and large-scale scenes. EffGS combines frequency-aware guidance, localized density control, and adaptive primitive scale modulation. First, an importance scoring mechanism combines pixel-wise reconstruction errors with a difference-of-Gaussians mask scheduled over training to provide stage-dependent spatial guidance. Second, localized densification and pruning restricts density modifications to Gaussians with valid projected footprints in the sampled views. Third, learnable per-Gaussian scale modulation adjusts effective primitive extent during optimization while retaining the Compact Box rasterization rule. Extensive experiments on bounded and large-scale scene datasets demonstrate a favorable balance between reconstruction quality, training time, and primitive count. Component ablations and matched-primitive-budget comparisons further support the effectiveness of the framework.
Changbai Li, Shuo Yang, Yichen Yang +2
Beihang University · Nanyang Technological University
Reducing the number of Gaussian-tile pairs is one of the most promising approaches to improve 3D Gaussian Splatting (3D-GS) rendering speed on GPUs. However, the importance difference existing among Gaussian-tile pairs has never been considered in the previous works. In this paper, we propose AdaGScale, a novel viewpoint-adaptive Gaussian scaling technique for reducing the number of Gaussian-tile pairs. AdaGScale is based on the observation that the peripheral tiles located far from Gaussian center contribute negligibly to pixel color accumulation. This suggests an opportunity for reducing the number of Gaussian-tile pairs based on color contribution. AdaGScale efficiently estimates the color contribution in the peripheral region of each Gaussian during a preprocessing stage and adaptively scales its size based on the peripheral score. As a result, Gaussians with lower importance intersect with fewer tiles during the intersection test, which improves rendering speed while maintaining image quality. The adjusted size is used only for tile intersection test, and the original size is retained during color accumulation to preserve visual fidelity. Experimental results show that AdaGScale achieves a geometric mean speedup of 13.8x over original 3D-GS on a GPU, with only about 0.5 dB degradation in PSNR on city-scale scenes.