3D Gaussian Splatting (3DGS) enables real-time novel-view synthesis but remains limited on GPUs at high resolutions. Through a stage-wise Roofline characterization, we identify two distinct hardware bottlenecks: global memory traffic dominates the front end, whereas instruction throughput limits rasterization. Guided by this analysis, we develop RoofGS, a rendering framework that applies bottleneck-specific optimizations rather than generic kernel acceleration. For the memory-bound front end, we design a resolution-adaptive quantized depth sorting key that compresses each key to 32 bits. For the compute-bound rasterizer, we introduce a range-aware bit-level fast exponential approximation tailored to the bounded exponent range after opacity culling, with a derived per-pixel error bound. These two core techniques are complemented by additional optimizations (kernel fusion, compact attribute storage, culling, dual-pixel evaluation) that additionally reduce memory traffic and improve instruction-level parallelism. Experiments show that RoofGS achieves a 10.1× end-to-end speedup over 3DGS at 4K on an RTX 4090, increasing throughput from 61 to 616 FPS, with only a 0.028 dB PSNR loss.
Figures & tables
Fig. 1: Rendering pipeline comparison. RoofGS fuses preprocessing and duplication, employs INT8 spherical harmonics and quantized depth sorting, and accelerates rendering through fast exponential approximation and dual-pixel parallelism.
Fig. 2: Overall architecture of RoofGS. It streamlines the pipeline through quantization-aware kernel fusion in preprocessing, a compressed 32-bit radix sort, and hardware-accelerated rasterization using dual-pixel instruction-level parallelism.
Symbol
Description
μ,r,s,α
Gaussian mean, rotation, scale, and opacity.
μ′,Σ′
Projected 2D mean and covariance matrix.
M,Ndup
Average tile duplication factor and total duplicated instances.
Skv,Npass
Key-value entry size and number of radix-sort passes.
I=F/B
Arithmetic intensity, defined as operations divided by data movement.
Table I: Notation used in Roofline characterization.
3DGS [ 6 ]
RoofGS
PUP 3D-GS [ 31 ]
PUP + RoofGS
Scene
1080p
4K
1080p
4K
1080p
4K
1080p
4K
train
157
46
1478
530
642
160
3000
1217
truck
167
52
1348
585
352
98
2673
997
drjohnson
131
38
1294
586
576
158
3248
1371
playroom
175
53
1570
699
633
164
3414
1408
Mean
158
47
1423
600
551
145
3084
1248
Table II: Orthogonality verification on RTX 4090: FPS and speedup over 3DGS (1080p and 4K).
Fig. 3: Qualitative comparison and residual error visualization. Each row shows a representative test view. From left to right: Ground Truth (GT), baseline 3DGS, absolute residual map of 3DGS ( ∣GT−3DGS∣ ), RoofGS (Ours), absolute residual map of RoofGS ( ∣GT−RoofGS∣ ), and amplified difference map ( ∣3DGS−RoofGS∣ ). Red insets highlight zoomed-in regions containing fine details. RoofGS preserves reconstruction quality nearly identical to that of standard 3DGS. The amplified difference maps (rightmost column) confirm that residual deviations between the two methods are minimal and primarily confined to high-frequency edges. Single-view quantitative metrics (PSNR) are overlaid on the rendered images. The right colorbar denotes the absolute RGB error scale [0,0.3] .
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) has significantly advanced real-time novel view synthesis by representing scenes as dense collections of anisotropic 3D Gaussian primitives. However, the irregular spatial distribution of Gaussians often leads to poor GPU utilization, as warp divergence and redundant computation degrade rendering performance. To address this, we present Local-GS, a warp-coherent rendering paradigm that, organizes Gaussian primitives with respect to SIMT (Single Instruction, Multiple Threads) execution boundaries rather than scene geometry. Specifically, we propose three warp-coherent stages: a hoisting stage that precomputes shared parameters at tile level, a culling stage that discards warps with no contribution, and a blending stage that replaces per-pixel branching with a uniform instruction stream. Across extensive benchmarks on multiple datasets, Local-GS improves efficiency without compromising quality. As a plug-and-play optimization, it provides additional performance gains to all tested baselines, culminating in a 7.76× speedup on Deep Blending scenes.
Yang Luo, Yan Gong, Yongsheng Gao +3
State Key Laboratory of Robotics and Systems, Harbin Institute of Technology, Harbin 150001, China · State Key Laboratory of Intelligent Green Vehicle and Mobility, the School of Vehicle and Mobility, Tsinghua University, Beijing 100084, China · Department of Computer Science and Technology, Tsinghua University, Beijing 100084, China
Consumer-level applications require fast optimization of 3D Gaussian Splatting (3DGS) with high-fidelity novel view rendering. However, existing 3DGS acceleration approaches still incur substantial computation on redundant pixels while sacrificing fine details. In this paper, we present TurboGS, an error-guided training framework that accelerates 3DGS by concentrating optimization on perceptually informative pixels. TurboGS is built upon four core components: (1) a tile-wise sparse pixel sampling, which, driven by multi-view reconstruction errors during training, prioritizes challenging regions and skips well-reconstructed ones to avoid redundant gradient computation; (2) a tile-wise structure-aware loss with sparse Normalized Cross-Correlation, which provides sparse yet effective supervision to preserve fine details and stabilize training; (3) an error-driven Gaussian density control strategy, which dynamically allocates model capacity and removes redundant primitives; and (4) a tailored hybrid optimizer that couples Hessian-informed updates with Adam moment damping to stabilize and improve convergence under sparse supervision. Experiments on standard benchmarks demonstrate that TurboGS can deliver on par or superior rendering quality within 100 seconds on a single RTX 5090 GPU card (up to 10x training speedup over vanilla 3DGS).
Zheng Dong, Daifei Qiu, Pinxuan Dai +5
Zhejiang Sci-Tech University · Malanshan Audio&Video Laboratory · CAD&CG Laboratory, Zhejiang University +2