Organizations: The University of Texas at Arlington · Snap Inc. · The University of Texas at Dallas · University of Georgia · Argonne National Laboratory
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.
Figures & tables
Figure 1
Method
Stage
Order
Dim.
FlashGS, Speedy-Splat,
Culling, scheduling
Sorted
RGB
AdR-Gaussian, HiGS
TC-GS, GEMM-GS
Alpha (TC)
Sorted
RGB
ORANGE
Blending (NPU)
Sorted
RGB
Sort-Free, StochasticSplats
Sorting
None
RGB
Duplex-GS
Sorting
Proxy
RGB
Table 1: Positioning of related methods. TC: Tensor Cores.
Figure 3: Instruction-level dependency and wait stalls. Conventional front-to-back alpha compositing introduces a long serial instruction sequence chain, leading to a strong wait stall.
Stage
Kernel
%
Rendering
Preprocessing
7.2
DuplicateWithKeys
4.1
Sorting
14.3
RenderCUDA
51.3
Decoding
—
19.2
Post-Processing
—
3.8
Table 2: Pipeline latency breakdown.
Figure 4: Overview of our tile-based warp-level MMA rendering pipeline. Each warp processes 32 pixels and packs 16 valid Gaussians into a weight matrix W . Their features are fetched in 8-channel slices, so only the current slice resides in shared memory, and Tensor Cores multiply W with each slice while the next slice is being fetched.
Mip-NeRF 360
LERF
Method
PSNR
SSIM
LPIPS
mIoU
LocAcc
FPS
PSNR
SSIM
LPIPS
mIoU
LocAcc
FPS
3DGS [ 19 , 39 ]
30.12
0.910
0.181
0.536
0.698
156.0
23.91
0.856
0.219
0.419
0.632
237.9
3DGS(+TC-GS) [ 29 ]
30.14
0.911
0.183
0.536
0.698
295.1
23.97
0.856
0.218
0.419
0.632
310.3
MatrixSplat
30.35
0.911
0.178
0.541
0.730
599.9
23.80
0.851
0.225
0.445
0.679
702.6
Table 3: Quantitative comparison on Mip-NeRF 360 (OVS) and LERF. We report image reconstruction quality, semantic performance, and end-to-end rendering speed. Following LangSplat [ 39 ] , mIoU and localization accuracy (LocAcc) are evaluated based on rendered language features. FPS follows the end-to-end protocol (Appendix C ) on an RTX 4090. We use 3DGS equipped with the TC-GS [ 29 ] module as 3DGS(+TC-GS). Best results for each metric are bold ; LPIPS is lower-is-better, and all other metrics are higher-is-better.
3D-OVS
Method
PSNR
SSIM
LPIPS
mIoU
LocAcc
FPS
3DGS [ 19 , 39 ]
24.71
0.757
0.234
0.802
0.937
162.0
3DGS(+TC-GS) [ 29 ]
24.66
0.749
0.234
0.802
0.937
294.8
MatrixSplat
24.89
0.752
0.239
0.804
0.985
510.9
Table 4: Quantitative comparison on 3D-OVS. Same setting as Tab. 3 .
Figure 5: Runtime breakdown of the rendering kernel on the Mip-NeRF 360 datasets.
3D-OVS
LERF
Mip-NeRF 360
Method
FPS
PSNR
LPIPS
FPS
PSNR
LPIPS
FPS
PSNR
LPIPS
3DGS [ 19 ]
210.2
24.78
0.239
357.0
23.91
0.217
278.9
30.13
0.183
Sort-Free (WSR) [ 15 ]
240.3
24.55
0.239
256.1
23.90
0.227
215.7
30.35
0.178
Duplex-GS [ 31 ]
319.1
25.40 ∗
0.171 ∗
332.9
24.46
0.223
127.9
30.46
0.222
MatrixSplat
521.8 (2.48 × )
24.88
0.234
891.9 (2.50 × )
23.80
0.228
660.0 (2.37 × )
30.35
0.181
Table 5: Comparison with order-independent methods. Kernel-isolated protocol (Appendix C ), D=8 , RTX 4090. Speedups over 3DGS are in parentheses. Sort-Free uses a third-party implementation. ∗ Duplex-GS on 3D-OVS uses the official pretrained checkpoint; other Duplex-GS entries are retrained with the official code and default settings.
Figure 6: Embedded feature scalability. Our method consistently reduces blending kernel time over 3DGS as the feature dimension scales.
Figure 7: Visual comparison of quality and language accuracy on Room and Ramen. The number at the bottom right of each image is the rendering FPS.
Setting
D=8
16
32
64
128
256
512
Vanilla 3DGS
253.8
237.2
194.1
116.3
59.5
2.3
1.1
+ OIEFB
423.5
363.2
273.5
143.7
64.9
2.1
1.2
+ MMA execution
741.1
500.9
302.8
148.1
78.8
38.0
17.4
+ Warp-level packing
830.5
568.2
369.0
170.8
79.3
35.7
22.4
+ Lazy channel-batched fetching
830.8
622.6
399.5
269.1
144.5
72.1
41.1
Table 6: Component ablation across feature dimensions D . Average FPS over 3D-OVS and Mip-NeRF 360 scenes at a lower resolution than Tab. 5 ; each row adds one component.
Table 9: Integration into fast renderers. Kernel-isolated protocol (Appendix C ), D=8 , RTX 4090. Speedups in parentheses are relative to the host renderer.
Method
RTX 4090
RTX 6000 Ada
H100 80GB
3DGS
278.9
252.1
252.5
3DGS + MatrixSplat
660.0 (2.37 × )
595.4 (2.36 × )
587.5 (2.33 × )
FlashGS
996.4
932.7
769.7
FlashGS + MatrixSplat
2302.5 (2.31 × )
2190.3 (2.35 × )
1904.7 (2.47 × )
Appendix
Table 10: Cross-GPU results. FPS on Mip-NeRF 360 under the kernel-isolated protocol ( D=8 ). Speedups in parentheses are relative to the baseline in the row above.
Figure 9: Visual comparison of quality and language accuracy. We compare the 3DGS and our method on varying datasets. The number shown at the bottom right is rendering FPS. Following LangSplat [ 39 ] , the relevancy map is evaluated based on rendered language features.
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
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