3D Gaussian Splatting sorts every splat by depth in every frame. Viewers that draw splats with the hardware rasterizer and sort them on the CPU, as most web and mobile viewers do, spend most of the frame time in this sort. We present AbacusGS, which stores the blending order of a 3DGS scene in the scene layout. AbacusGS groups the splats into octree boxes of at most 128 splats and stores each box in order along an axis chosen at write time. In each frame, AbacusGS sorts only the visible boxes, and one dot product per box decides whether the box is read forward or backward. A short order-aware fine-tuning converts an existing 3DGS model, and the over operator of 3DGS stays unchanged. On 13 standard scenes, AbacusGS loses 0.13 dB PSNR on average against an equally fine-tuned 3DGS model. In an OpenGL viewer that orders splats on the CPU, AbacusGS renders frames 4.5 times faster than per-splat sorting. We also present a compact format of 17 bytes per splat and a CUDA tile renderer that use the same order. The code will be released.
Figures & tables
Figure 2: Overview of AbacusGS at write time (a), in every frame (b), and in the draw call of a hardware rasterizer (c).
Figure 3: Crops of a test view rendered from the same base model by 3DGS, by StochasticSplats at 16 samples per pixel, by the two-level order before fine-tuning, and by AbacusGS, labeled with the PSNR of the full image.
Splat
Mip-NeRF 360
Tanks&Temples
Deep Blending
Method
Over
sort
PSNR ↑
SSIM ↑
LPIPS ↓
PSNR ↑
SSIM ↑
LPIPS ↓
PSNR ↑
SSIM ↑
LPIPS ↓
Official 3DGS rasterizer and metrics
3DGS [ 21 ] , reported
✓
✓
27.21
0.815
0.214
23.14
0.841
0.183
29.41
0.903
0.243
3DGS, our retraining
✓
✓
27.49
0.816
0.215
23.75
0.853
0.169
29.75
0.907
0.239
StochasticSplats, 16 spp
✗
✗
24.06
0.589
0.401
20.65
0.504
0.439
27.33
0.688
0.395
StochasticSplats, 64 spp
✗
✗
26.25
0.730
0.279
22.64
0.691
0.307
28.99
0.830
0.283
Table 1: Image quality on 13 scenes, with the upper block evaluated by the official 3DGS code and the lower block evaluated by our renderer and metrics.
Figure 4: PSNR change of every scene against its equally fine-tuned control, sorted by the change of the compact model.
Figure 5: Crops of the compact model and its control on two test views with a large loss of the compact model, labeled with the PSNR of the full image.
Method
Compositing
Sorted
From
M360
T&T
DB
WSR [ 17 ]
weighted sum
nothing
scratch
-0.02
+0.47
+0.22
Mobile-GS [ 6 ]
order-indep.
nothing
scratch
-0.09
-0.05
+0.52
Duplex-GS [ 28 ]
sum in cell
cells
scratch
+0.22
+0.75
+0.65
Stippling [ 18 ] , 1 spp
stochastic
nothing
3DGS
-1.18
-0.67
-0.19
StochasticSplats † , 64 spp
stochastic
nothing
3DGS
-1.25
-1.11
-0.75
StochasticSplats † , 1024 spp
stochastic
nothing
3DGS
-0.16
-0.19
-0.03
Table 2: PSNR change of sort-free and coarse-order methods relative to the 3DGS row of each paper, where † marks our runs from the official 3DGS models.
Order
Frame
Items
Method
1 ×
1 ×
2 ×
4K
per frame
OpenGL, ordering on one CPU thread
3DGS, depth sort
24.1
26.8
27.3
30.6
2,058k
3DGS, box culling, depth sort
33.1
35.0
35.4
39.0
1,099k
Per-frame in-box sort
48.9
50.7
51.3
54.0
1,099k
AbacusGS, expanded indices
8.8
10.7
11.4
13.7
1,099k
Table 3: Ordering and frame time in milliseconds, as medians over 13 scenes for OpenGL and means over 13 scenes for CUDA.
Scene storage, bytes per splat and load time
Method
File
GPU memory
Load, 1st frame
3DGS, PLY file
248.0
236.5
293 ms
AbacusGS , our loader
19.3
36.8
69 ms
AbacusGS, 16-byte headers ∗
17.1
17.3
–
WebGL2 in headless Chrome, phone viewport, CPU throttled 4 ×
Method
Order (ms)
Frame (ms)
FPS
Table 4: File size, GPU memory, and loading time averaged over 13 scenes, with the row marked by ∗ computed from the format, and medians of the browser emulation over four scenes.
Δ PSNR
Worst
Δ SSIM
Variant
no FT
FT
scene
FT
Official 3DGS base models, K=128
Float
reversible order
-1.27
-0.126
-0.31
-0.0019
per-frame in-box sort
–
-0.089
-0.20
-0.0013
reversible, K=64
-0.93
-0.089
-0.21
-0.0014
Compact
reversible, full header
-1.57
-0.172
-0.46
-0.0037
Table 5: PSNR and SSIM change of design variants against the equally fine-tuned control.
Cameras
Median
Lowest
Largest drop
test cameras
37.6
33.4
–
moved backward
37.1
28.4
5.0
moved forward
38.0
31.5
1.9
moved up
37.1
31.1
3.5
moved sideways
37.2
31.7
1.7
Table 6: PSNR in decibels between the two-level order and the per-splat depth order on the same splats over 13 scenes.
3D Gaussian Splatting (3DGS) has become the standard for real-time novel view synthesis on commodity GPUs. Its pipeline ties spatial partitioning and rasterization to one tile size, yet the two pull in opposite directions: partitioning, which bins and depth-sorts gaussians, grows cheaper with larger tiles, while rasterization gets cheaper with smaller ones. Prior acceleration work reduces the cost of individual stages but keeps both locked to that single scale, where a few dense tiles dominate frame time. We present Hierarchically Tiled Gaussian Splatting (HiGS), which gives each its own scale: partitioning runs over coarse macro-tiles, while rasterization runs over the fine render tiles within them. Rasterization work is then issued in proportion to the gaussians in each macro-tile rather than per tile, so dense regions spread across many parallel units instead of serializing through one. Across tested scenes, HiGS renders up to 15.8x faster than the original 3DGS and outperforms every other rasterizer we evaluate, while preserving exact front-to-back alpha compositing.
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
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