3D Gaussian Splatting (3DGS) enables photorealistic, real-time rendering on commodity GPUs and is increasingly adopted in generative world models and autonomous driving simulators. However, existing optimizations rely on algorithmic changes that often require retraining, or on specialized accelerators that lack flexibility across evolving 3DGS variants. In this paper, we identify a fundamental inefficiency in GPU-based 3DGS rendering: severe SM-level load imbalance caused by uneven workloads across screen tiles. This imbalance creates a long execution tail, leaving most SMs idle while a few process computationally intensive tiles, particularly in large-scale urban scenes. To address this, we present a software-defined GPU scheduling approach that mitigates the execution tail. Our approach uses a persistent kernel to schedule heavy tiles first and selectively chunks outlier tiles across multiple CTAs. A lightweight per-frame policy determines when and how much to chunk using tile statistics already available in the rendering pipeline. Our approach requires neither retraining nor specialized hardware and can be applied orthogonally to existing optimizations across diverse 3DGS variants. Averaged per scene, it accelerates alpha blending by up to 2.93x on a large-scale urban scene, and by up to 5.6x on its most imbalanced frames, while retaining the original alpha blending formulation.
Figures & tables
Figure 1: Common rendering pipeline of 3DGS and its variants.
Figure 2
Figure 4: Distribution of per-tile Gaussian counts across small-scale and large-scale scenes, the latter shaded blue. Each raincloud plot shows the density (violin), interquartile range (box), and per-tile samples (dots). Driving scenes use the front camera.
Figure 5: (a) Execution tail caused by tile imbalance. (b) Per-tile Gaussian counts and corresponding SM activity timelines for representative frames, sampled with Nsight Compute NVIDIA Corporation (2026) .
Figure 6: CDF of per-frame SM activity across 3DGS variants and datasets (front camera for driving scenes), measured with Nsight Compute.
Figure 7: (a) LPT scheduling via a persistent kernel. (b) SM activity before and after LPT scheduling for the frames in Figure 5 (b). (c) LPT speedup over Vanilla versus the heaviest tile relative to the per-CTA share.
Figure 8: (a) Depth-wise chunking and saturation signaling. (b) Per-frame speedup of Chunking-only over LPT-only versus the number of chunks.
Figure 9: (a) Stream co-execution of chunk and LPT kernels. (b) Per-frame speedup of co-execution over LPT-only (left) and Chunking-only (right).
Figure 10: Per-frame chunking cost estimation on a 3DGS train frame. Left: Workload distribution after chunking. Right: Estimated cost versus the number of chunked tiles.
Figure 11: Effectiveness of the per-frame chunking policy.
Figure 12: Speedup over Vanilla on driving scenes (top) and standard 3DGS benchmarks (bottom), per frame versus tile imbalance (left) and per scene (right).
Renderer
Dataset
#Scene
Δ PSNR
Δ SSIM
Δ LPIPS
M360
9
+0.0001
0.0000
0.0000
T&T
2
− 0.0001
0.0000
0.0000
3DGS
DB
2
− 0.0004
0.0000
0.0000
M360
3
+0.0002
0.0000
0.0000
2DGS
T&T
1
− 0.0001
0.0000
0.0000
M360
3
+0.0002
0.0000
0.0000
Table 1: Quality difference of Chunking-only from Vanilla.
Figure 13: Speedup of our approach over Vanilla with CityGaussianV2 on MatrixCity and 3DGUT on NuRec views (CL: cross-left, FW: front-wide).
Figure 14: Per-frame speedup of our approach over SwiftGS and HiGS.
Figure 15: Speedup of our approach over Vanilla on the GB10 (48 SMs) and RTX A6000 (84 SMs).
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
Recent breakthroughs in 3D Gaussian Splatting (3DGS) have advanced neural rendering with high fidelity and speed. However, its performance degrades significantly in large-scale scenes due to the computational burden of tile-based rasterization. Existing optimization efforts either require costly scene re-training or focus on narrow aspects of the pipeline, overlooking critical inefficiencies in real-world deployments. Through a comprehensive analysis, we identify three primary sources of redundancy and low GPU utilization: redundant inter-frame pre-processing, viewpoint-based occlusion redundancy, and severe tile-level load imbalance. To address these issues, we propose CaT-GS, a novel and efficient 3DGS rendering pipeline. CaT-GS introduces a speculative multi-frame preprocessing method to eliminate redundant computations across consecutive frames, and an inter-frame caching mechanism to eliminate viewpoint redundant rendering stages. Furthermore, it refactors rasterization tasks with a dedicated kernel to mitigate tile load imbalance, significantly boosting GPU utilization. Extensive experiments demonstrate that CaT-GS achieves a speedup of up to 10 times over the original 3DGS and up to 70% over previous state-of-the-art methods, establishing a new benchmark for high-fidelity, real-time rendering of large-scale scenes.
Tingjia Zhang, Bo Chen, Shengzhong Liu +2
Shanghai Jiao Tong University · University of Illinois Urbana-Champaign
3D Gaussian Splatting (3DGS) has emerged as a mainstream representation for real-time novel view synthesis and 3D reconstruction. However, existing 3DGS rendering pipelines are poorly aligned with modern GPU architectures: depth-sorted alpha compositing introduces strong per-pixel sequential dependencies, limiting parallelism and resulting in scalar FMA-dominated execution that underutilizes high-throughput matrix units such as Tensor Cores. This mismatch becomes more severe for multimodal and semantically enriched 3DGS, where high-dimensional features must be accumulated from millions of Gaussians, leading to rapidly increasing computation and memory costs. We propose MatrixSplat, a matrix-parallel rendering framework for feature-scalable 3DGS on modern GPUs. We first identify the sequential dependency of alpha compositing as a key obstacle to efficient high-dimensional feature rendering, and adopt an order-independent weighted accumulation formulation that transforms feature rendering into matrix-oriented computation. Our framework features three key designs: (i) a tile-based splatting pipeline that maps feature accumulation to warp-level matrix-multiply-accumulate execution on Tensor Cores; (ii) a warp-granularity Gaussian packing strategy that mitigates visibility irregularity and improves feature reuse; and (iii) a lazy channel-batched feature-fetching pipeline that reduces shared-memory pressure, maintains high warp occupancy, and overlaps memory access with matrix execution for high-dimensional features. On Mip-NeRF 360, LERF, and 3D-OVS, MatrixSplat achieves up to 3.8× speedup over 3DGS and 2× over TC-GS while maintaining rendering quality and semantic accuracy, and further reduces render-kernel time by up to 36.7× for high-dimensional features. Integrated into existing fast renderers, it provides an additional 1.69-2.84× speedup.
Yangming Zhang, Siyi Wu, Jian Wang +5
The University of Texas at Arlington · Snap Inc. · The University of Texas at Dallas +2