Radiance field-based rendering methods have attracted significant interest from the computer vision and computer graphics communities. They enable high-fidelity reconstruction with complex real-world lighting effects, but at the cost of high rendering time. 3D Gaussian Splatting solves this issue with a rasterization-based approach for real-time rendering, enabling applications such as autonomous driving, robotics, virtual reality, and extended reality. However, due to the lack of format and rendering standardization, the ecosystem is fragmented into specific viewers. This makes it difficult to integrate these methods into traditional mesh-based rendering pipelines, which is a common use case for interactive applications. To address this limitation, we propose a framework that uses Nvidia's interprocess communication (IPC) APIs to provide an implementation-agnostic rendering server, enabling the results to be viewed in external clients such as Unity, Blender, and OpenGL viewers. The code is available at https://github.com/RockyXu66/splatbus.
Figures & tables
Figure 1. Overview of SplatBus. A Python rendering server exposes rendered color and depth buffers through CUDA IPC, while external clients exchange camera and scene controls over sockets.
Figure 2. Screenshots of SplatBus clients showing plug-and-play integration with various 3DGS-based methods and compositing with mesh rendering pipelines.
720p
1080p
1440p
4K
Original render, avg. (ms)
4.3
6.0
8.5
15.4
+ Handoff (ms)
0.1
0.2
0.3
1.0
Overhead, avg.
2.3%
3.3%
3.5%
6.5%
GPU-mem overhead (MB)
7.0
15.8
28.1
63.3
Table 1. CUDA-IPC handoff overhead averaged over three Mip-NeRF 360 scenes; overhead is handoff time divided by render time.
Stage (ms)
CUDA-IPC
CPU-shm
Enc. loss.
Enc. lossy
Render
5.2
5.1
6.6
5.1
Handoff (server)
0.4
3.8
0.2
0.4
Transfer + recv
0.4
2.9
45.8
27.4
Viewer copy + draw
1.9
2.1
0.7
1.2
Pipeline total
7.9
13.9
53.3
34.1
Displayed FPS
169.4
118.4
52.6
92.2
Table 2. End-to-end latency (ms) and throughput (fps). “Enc.” denotes NVENC. Stage timings use per-frame device synchronization; displayed FPS does not.
SplatBus
Native Unity
Scene
Res.
SIBR
OpenGL (on-request)
OpenGL (free-run)
Unity (free-run)
Unity- GaussianSplatting
gsplat- unity
room
720p
352.2
300.2
284.1
253.0
441.1
688.6
1080p
205.9
185.2
169.4
148.5
372.3
435.4
1440p
135.4
122.3
108.2
99.9
292.7
290.9
4K
70.2
62.7
52.4
53.0
191.0
167.8
garden
720p
207.5
172.6
161.3
154.1
138.5
243.9
Table 3. Displayed throughput (fps) of SIBR, SplatBus clients, and native Unity implementations.
Scene
System
PSNR ↑
SSIM ↑
LPIPS ↓
room
SplatBus
31.25
0.914
0.221
UnityGaussianSplatting
30.82
0.885
0.221
gsplat-unity
30.29
0.874
0.228
garden
SplatBus
27.04
0.857
0.110
UnityGaussianSplatting
26.87
0.852
0.113
gsplat-unity
22.50
0.737
0.188
Table 4. Fidelity on Mip-NeRF 360 test views; SplatBus reproduces the original rasterizer.
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.
Generating high-quality novel views at real-time frame rates remains a central challenge in 3D vision, particularly in sparse-view scenarios. Neural radiance fields have demonstrated robust reconstruction from limited observations, but their reliance on volumetric rendering leads to high computational cost and slow inference. In contrast, Gaussian Splatting methods achieve real-time rendering through rasterization, but their optimization is highly sensitive to the quality of the initial geometry. This sensitivity becomes especially problematic in sparse-view settings, where limited observations often lead to incomplete or noisy point-cloud reconstructions. In this work, we present AugSplat, a simple framework for improving Gaussian Splatting in sparse-view regimes using radiance-field-based view augmentation. We first train a radiance field on the sparse input views and use it to synthesize additional images from nearby novel viewpoints, increasing the effective view-space coverage available for supervision. These synthetic views are then used as auxiliary supervision during Gaussian Splatting optimization. We study two variants: Staged AugSplat, which uses synthetic views for an initial optimization phase before switching to real images, and Dual AugSplat, which jointly trains on real and synthetic views with a decaying synthetic loss weight. Experiments on sparse-view mip-NeRF 360 scenes show that AugSplat improves reconstruction quality over standard Gaussian Splatting. Staged AugSplat achieves the strongest average performance, while Dual AugSplat provides a closely performing formulation that keeps real-image supervision active throughout training, and both variants preserve real-time rendering at inference.
Lorenzo Lazzaroni, Riccardo Bollati, Daniel Barath +2
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.