LoBE-GS: Load-Balanced and Efficient 3D Gaussian Splatting for Large-Scale Scene Reconstruction

1National Tsing-Hua University 2NVIDIA AI Technology Center
WACV 2027

Abstract

3D Gaussian Splatting (3DGS) has established itself as an efficient representation for real-time, high-fidelity 3D scene reconstruction. However, scaling 3DGS to large and unbounded scenes such as city blocks remains difficult. Existing divide-and-conquer methods alleviate memory pressure by partitioning the scene into blocks and training on multiple, non-communicating GPUs, but introduce new bottlenecks: (i) partitions suffer from severe load imbalance since uniform or heuristic splits do not reflect actual computational demands, and (ii) coarse-to-fine pipelines fail to exploit the coarse stage efficiently, often reloading the entire model and incurring high overhead.

In this work, we introduce LoBE-GS, a novel Load-Balanced and Efficient 3D Gaussian Splatting framework that re-engineers the large-scale 3DGS pipeline. Specifically, LoBE-GS introduces a load-balanced KD-tree scene partitioning scheme with optimized cutlines that balance per-block camera counts. To accelerate preprocessing, it employs depth-based back-projection for fast camera assignment, reducing processing time from hours to minutes. It further reduces training cost through two lightweight techniques: visibility cropping and selective densification.

On large-scale urban and outdoor datasets, LoBE-GS reduces scene-partitioning time by up to an order of magnitude and the worst-block fine-training time by up to 3× relative to CityGaussian, yielding up to 9.1× faster end-to-end training than prior partition-based methods while maintaining competitive reconstruction quality. LoBE-GS provides a communication-free alternative with favorable quality–efficiency trade-offs under matched GPU budgets.

Method

LoBE-GS pipeline overview

Overview of the LoBE-GS pipeline. We first train a coarse 3DGS model, then perform load-balanced KD-tree partitioning with fast camera selection (FCS), which splits the scene into blocks and efficiently assigns high-coverage cameras to each block using reusable depth-based 3D cues. Each split is further refined via cutline refinement (CR) to balance the workload across blocks. Before and during parallel fine-tuning, visibility cropping (VC) and selective densification (SD) reduce per-block optimization cost while preserving reconstruction quality. Finally, we prune Gaussians outside each block and merge all blocks into a unified, high-quality model.

Experiments

Setup. We evaluate on six large-scale scenes: Building and Rubble from Mill19, Residence and Sci-Art from UrbanScene3D, and the synthetic MatrixCity-BigCity and MatrixCity-SmallCity. We compare against state-of-the-art large-scale 3DGS methods — CityGaussian, VastGaussian, and Grendel-GS — as well as a strong 3DGS† baseline. Reconstruction quality is measured with PSNR, SSIM, and LPIPS (no post-hoc color correction), and efficiency by end-to-end wall-clock training time under a fixed GPU budget TE2E(K). All experiments run on a single node with 8× NVIDIA L40 GPUs.

Training Efficiency

End-to-end wall-clock training time under an 8-GPU budget (shorter is better). Among partition-based methods, LoBE-GS is consistently the fastest.

LoBE-GS (Ours) VastGaussian CityGaussian
axis max 141:00
140:31
57:29
15:27
MatrixCity-BigCity
axis max 7:00
06:53
04:31
02:08
MatrixCity-SmallCity
04:51
02:28
01:33
Building
03:33
01:15
01:01
Rubble
06:11
02:28
01:38
Residence
02:52
01:33
00:49
Sci-Art

Up to 9.1× faster end-to-end than CityGaussian, at competitive quality.

MatrixCity-BigCity is roughly 20× longer to train than the other scenes and is plotted on its own axis; bar heights are comparable within each panel, not across panels.


Quantitative Results

Method MatrixCity-BigCity MatrixCity-SmallCity Building
PSNRSSIMLPIPSTE2EMpeak#GS PSNRSSIMLPIPSTE2EMpeak#GS PSNRSSIMLPIPSTE2EMpeak#GS
Single-model / distributed methods
3DGS† 22.640.6600.45424:2916.5310.5 25.570.7940.31502:1017.0611.3 20.460.7200.30501:309.946.2
Grendel-GS 23.010.7400.35410:4621.8668.1 26.960.8500.22402:0510.9920.8 22.520.7640.27700:468.186.9
Partition-based methods
VastGS 29.170.8890.17357:2920.10196.5 26.920.8450.23504:3111.7119.1 21.310.7430.27702:286.7310.5
CityGS 27.870.8380.265140:3117.2058.4 27.460.8650.20406:5314.1123.6 21.550.7780.24604:5120.3913.2
LoBE-GS (Ours) 28.880.8880.17015:2711.50197.6 27.690.8750.18502:087.4228.9 22.130.7900.23101:339.3413.9
Method Rubble Residence Sci-Art
PSNRSSIMLPIPSTE2EMpeak#GS PSNRSSIMLPIPSTE2EMpeak#GS PSNRSSIMLPIPSTE2EMpeak#GS
Single-model / distributed methods
3DGS† 25.470.7770.27701:105.843.7 21.440.7910.23601:226.634.1 21.340.8330.23200:483.642.1
Grendel-GS 25.720.7680.30100:305.903.2 22.370.8040.22700:4310.994.8 22.760.8470.22200:3311.202.0
Partition-based methods
VastGS 25.130.7490.31601:153.755.3 20.880.7780.24202:284.747.9 20.880.7960.29101:333.202.9
CityGS 25.770.8130.22803:3314.569.7 22.000.8130.21106:1121.6610.8 21.390.8370.23002:5214.043.7
LoBE-GS (Ours) 25.930.8130.23201:019.409.2 21.480.8050.20901:389.0011.2 21.450.8430.21900:495.494.5

Table 1. Quantitative comparison on MatrixCity, Mill19, and UrbanScene3D under an 8-GPU budget. We report PSNR, SSIM, LPIPS, end-to-end runtime TE2E(8) (hh:mm), peak per-GPU memory Mpeak (GB), and final model size #GS (millions of Gaussians).
best second third reconstruction quality across all five methods. bold marks the best runtime among partition-based methods.


Runtime Breakdown & Load Balancing

Method MatrixCity-SmallCity Building Rubble Residence Sci-Art
TcoarseTpartmax Tfine TcoarseTpartmax Tfine TcoarseTpartmax Tfine TcoarseTpartmax Tfine TcoarseTpartmax Tfine
VastGS –00:4801:13 –00:0500:44 –00:0400:39 –00:0800:49 –00:2000:31
CityGS 00:5201:3901:00 00:5900:2101:06 01:0600:0901:14 00:4300:3101:22 00:4200:0800:45
LoBE-GS (Ours) 00:3800:0800:27 00:2500:0200:28 00:2300:0100:25 00:2600:0300:26 00:1600:0200:20

Table 2. Runtime breakdown for partition-based methods (hh:mm): coarse-stage time Tcoarse, partitioning time Tpart, and the slowest fine-stage block max Tfine (the straggler / load-balancing metric). “–” = stage not used by that method.

Visual Comparisons

Baseline method Ours (LoBE-GS)
Ours