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

Sheng-Hsiang Hung; Ting-Yu Yen; Wei-Fang Sun; Simon See; Shih-Hsuan Hung; Hung-Kuo Chu

cs.CVOct 2, 2025

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

Authors: Sheng-Hsiang Hung, Ting-Yu Yen, Wei-Fang Sun, Simon See, Shih-Hsuan Hung, Hung-Kuo Chu

Organizations: National Tsing Hua University · NVIDIA AI Technology Center (NVAITC)

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 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 worst-block fine-training time by up to $3.2\times$ relative to CityGaussian. It also substantially reduces end-to-end and post-coarse training time under matched GPU budgets while maintaining competitive reconstruction quality. LoBE-GS thus provides a communication-free alternative with favorable quality-efficiency trade-offs. The associated code is available at: https://github.com/Sunnyhong0326/lobe-gs

Figures & tables

Figure 1: Overview of our framework. We first train a coarse 3DGS model. Next, we perform load-balanced KD-tree partitioning with fast camera selection , which partitions the scene into blocks and efficiently assigns high-coverage cameras to each block using reusable depth-based 3D cues. We further refine each split via cutline refinement to balance the workload across blocks. Before and during parallel fine-tuning, we apply visibility cropping and selective densification to 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.

Panel of Figure 2 — Figure 2: Cutline refinement in load-balanced KD-tree scene partition. (a) A parent AABB is selected for splitting, and multiple cutline candidates are evaluated along the chosen axis in the zoomed region. (b) As the cutline percentile increases, the left-child camera count increases while the right-child camera count decreases, producing an approximately monotonic trade-off. We approximately minimize the maximum sibling camera count via binary search.

Method	MatrixCity-BigCity				MatrixCity-SmallCity				Building				Rubble				Residence
Method	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$
Single-model / distributed methods
3DGS †	22.64	0.660	0.454	24:29	25.57	0.794	0.315	02:10	20.46	0.720	0.305	01:30	25.47	0.777	0.277	01:10	21.44	0.791	0.236	01:22
Grendel-GS	23.01	0.740	0.354	10:46	26.96	0.850	0.224	02:05	22.52	0.764	0.277	00:46	25.72	0.768	0.301	00:30	22.37	0.804	0.227	00:43
Partition-based methods
VastGS	29.17	0.889	0.173	57:29	26.92	0.845	0.235	04:31	21.31	0.743	0.277	02:28	25.13	0.749	0.316	01:15	20.88	0.778	0.242	02:28

Table 1: Quantitative comparison on MatrixCity, Mill19, and UrbanScene3D datasets. We report PSNR, SSIM, LPIPS, and end-to-end runtime

T_{\text{E2E}}^{(8)}

under an 8-GPU budget. The best , second , and third best reconstruction quality are highlighted across five methods. For runtime, the fastest method among partition-based methods is highlighted in bold . All runtimes are reported in

hh

mm

. Full quantitative details are reported in Appendix Table A3 .

Panel of Figure 3 — Figure 3: Runtime-quality trade-off under matched GPU budgets. We compare reconstruction quality and end-to-end runtime under 2, 4, and 8 GPUs across two datasets and two metrics: (a,b) MatrixCity-SmallCity and (c,d) Building, with PSNR and LPIPS reported per dataset. For PSNR, upper-left is better; for LPIPS, lower-left is better. Markers indicate GPU budgets, and lines connect runs of the same method. The full runtime-quality trade-off is reported in Appendix Fig. A1 .

Figure 4: Qualitative comparison on MatrixCity, Building and Residence datasets. Full results are in Appendix Fig. A2

Method	MatrixCity-BigCity			MatrixCity-SmallCity			Building			Rubble			Residence
Method	$T_{\text{coarse}}$	$T_{\text{partition}}$	Max $T_{\text{fine}}$	$T_{\text{coarse}}$	$T_{\text{partition}}$	Max $T_{\text{fine}}$	$T_{\text{coarse}}$	$T_{\text{partition}}$	Max $T_{\text{fine}}$	$T_{\text{coarse}}$	$T_{\text{partition}}$	Max $T_{\text{fine}}$	$T_{\text{coarse}}$	$T_{\text{partition}}$	Max $T_{\text{fine}}$
VastGS	–	01:57	03:39	–	00:48	01:13	–	00:05	00:44	–	00:04	00:39	–	00:08	00:49
CityGS	07:30	99:12	02:41	00:52	01:39	01:00	00:59	00:21	01:06	01:06	00:09	01:14	00:43	00:31	01:22
LoBE-GS	03:52	00:54	00:50	00:38	00:08	00:27	00:25	00:02	00:28	00:23	00:01	00:25	00:26	00:03	00:26

Table 2: Runtime breakdown and load-balancing analysis for partition-based methods. For each dataset, we report coarse-stage optimization time

T_{\text{coarse}}

, partitioning time

T_{\text{partition}}

, and maximum fine-stage optimization time Max

T_{\text{fine}}

. Max

T_{\text{fine}}

measures the slowest fine-training block and serves as a load-balancing metric. A value of “–” indicates that the method does not include the corresponding stage. All units are

hh

mm

Method	MatrixCity - SmallCity					Building					Residence
Method	Max $T_{\text{fine}}$	$T_{\text{partition}}$	$M_{\text{peak}}$	PSNR	SSIM	Max $T_{\text{fine}}$	$T_{\text{partition}}$	$M_{\text{peak}}$	PSNR	SSIM	Max $T_{\text{fine}}$	$T_{\text{partition}}$	$M_{\text{peak}}$	PSNR	SSIM
w/o VC	01:39	00:08	22.1	27.74	0.876	01:00	00:02	13.4	21.76	0.785	00:51	00:03	11.9	21.35	0.800
w/o SD	00:41	00:08	9.2	27.72	0.875	00:46	00:02	10.6	21.63	0.781	00:44	00:03	9.4	21.45	0.803
w/o FCS	00:38	15:30	11.4	27.63	0.873	00:36	01:57	9.4	21.76	0.780	00:36	02:35	9.8	21.62	0.806
w/o CR	00:33	00:07	7.4	27.77	0.876	00:35	00:02	9.3	21.95	0.788	00:32	00:02	8.9	21.68	0.807
LoBE-GS	00:27	00:08	7.4	27.69	0.875	00:28	00:02	9.3	22.13	0.790	00:26	00:03	9.0	21.48	0.805

Table 3: Ablation on model components. We report the maximum fine-stage runtime across blocks (

\max T_{\text{fine}}

hh

mm

), partition time (

T_{\text{partition}}

hh

mm

), peak GPU memory across blocks (

M_{\text{peak}}

, GB), and rendering quality for LoBE-GS and its ablated variants without visibility cropping (VC), selective densification (SD), fast camera selection (FCS), and cutline refinement (CR) in KD-tree partition.

Figure 5: Proxy correlation for the top-10% heaviest blocks. Proxies and training time are

z

-normalized per scene before pooling. Colors denote datasets; highlighted points mark the heaviest blocks, with the dashed red line fitting this subset and

r

denoting its Pearson correlation. Camera count correlates most strongly with training time.

Figure 6: Worst-block fine-stage runtime across proxies. Max

T_{\text{fine}}

under different KD-tree proxies, with FCS, VC, and SD enabled. Camera Count (highlighted) is lowest across all datasets.

$K$	5	10	20	10	20	30
	Overlap@ $K$			$r^{(K)}$
Block area	0.35	0.41	0.31	0.18	0.43	0.41
Visible pts.	0.12	0.26	0.41	$-0.16$	0.01	0.03
Camera count	0.53	0.47	0.44	0.57	0.51	0.52

Table 4: Heavy-block prediction quality measured by Overlap@K and Pearson correlation (

r^{(K)}

Appendix figures & tables14 assets

Supplementary material from the paper’s appendix.

Appendix

Method	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$
VastGS (unofficial)	24.64	0.761	0.351	5:32
VastGS (ours)	26.92	0.845	0.235	4:31
LoBE-GS	27.69	0.875	0.185	2:08

Appendix

Table A1 : Effect of VastGS reproduction on MatrixCity-SmallCity. Effect of our point filtering for the unofficial VastGS reproduction.

Method	Init.	PSNR	SSIM	LPIPS
Grendel-GS	Triangulate	26.96	0.850	0.224
Grendel-GS †	Depth	27.32	0.862	0.197
LoBE-GS	Triangulate	27.69	0.875	0.185

Appendix

Table A2 : Effect of Grendel-GS initialization on MatrixCity-SmallCity. Effect of dense depth-sampled initialization for Grendel-GS.

Method	MatrixCity-BigCity						MatrixCity-SmallCity						Building
Method	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	$M_{\text{peak}}$	#GS	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	$M_{\text{peak}}$	#GS	PSNR	SSIM	LPIPS	$T_{\text{E2E}}^{(8)}$	$M_{\text{peak}}$	#GS
Single-model / distributed methods
3DGS †	22.64	0.660	0.454	24:29	16.53	10.5	25.57	0.794	0.315	02:10	17.06	11.3	20.46	0.720	0.305	01:30	9.94	6.2
Grendel-GS	23.01	0.740	0.354	10:46	21.86	68.1	26.96	0.850	0.224	02:05	10.99	20.8	22.52	0.764	0.277	00:46	8.18	6.9
Partition-based methods
VastGS	29.17	0.889	0.173	57:29	20.10	196.5	26.92	0.845	0.235	04:31	11.71	19.1	21.31	0.743	0.277	02:28	6.73	10.5

Appendix

Table A3 : Quantitative comparison on MatrixCity, Mill19, and UrbanScene3D datasets. We report PSNR, SSIM, LPIPS, end-to-end runtime

T_{\text{E2E}}^{(8)}

, peak per-GPU memory

M_{\text{peak}}

(GB), and final model size #GS (millions of Gaussians) under an 8-GPU budget. The best , second , and third best reconstruction quality are highlighted across five methods. For runtime and memory, the best among partition-based methods is highlighted in bold . All runtimes are reported in

hh

mm

Panel of Figure 14 — Figure A1 : Quality vs. end-to-end runtime under the same GPU budget. Each row is a dataset; columns report PSNR, SSIM, and LPIPS against end-to-end time. Per-method curves connect the 2, 4, and 8 GPU operating points. Up/left is better for PSNR and SSIM; down/left is better for LPIPS.

Figure A2 : Qualitative comparison on MatrixCity (MC), Mill19 and UrbanScene3D datasets.

Figure A3 : Block boundary evaluation. Top-view of the partitioned scene: gray points are Gaussians’ positions, red points are visible Gaussians from the corresponding camera, and dashed lines mark the KD-tree block boundaries.

MatrixCity-SmallCity
Method	PSNR	SSIM	LPIPS	$T_{\mathrm{part}}$	Max $T_{\mathrm{fine}}$
VastGS	26.60	0.840	0.249	0:48	0:44
CityGS	27.73	0.871	0.196	2:38	0:45
LoBE-GS (Ours)	27.69	0.875	0.185	0:08	0:27
Building
VastGS	21.65	0.765	0.265	0:05	0:35

Appendix

Table A4: Reconstruction quality and runtime across partition strategies.

T_{\mathrm{part}}

is partitioning, Max

T_{\mathrm{fine}}

the slowest block’s fine-stage training. Times are

hh

mm

. Best per scene in bold .

	LoBE-GS FCS (ours)			VastGS BBox
Dataset	Prec.	Rec.	F1	Prec.	Rec.	F1
MC-SmallCity	0.641	0.970	0.772	0.340	0.934	0.499
Building	0.792	0.914	0.848	0.677	0.895	0.771
Rubble	0.783	0.965	0.865	0.856	0.913	0.883
Residence	0.944	0.858	0.899	0.916	0.817	0.864
Sci-Art	0.890	0.917	0.903	0.889	0.903	0.896

Appendix

Table A5: Agreement of each camera selection method with the CityGS SSIM contribution reference, evaluated on a fixed coarse checkpoint. Precision and recall are measured against the reference selection; higher values indicate closer agreement with CityGS SSIM-based camera selection. Bold marks the higher F1 per scene.

#Blocks	$\tau$	PSNR	SSIM	LPIPS	$T_{\text{partition}}$
9	0.05	27.30	0.858	0.220	00:04
	0.10	27.39	0.863	0.212
	0.20	27.44	0.865	0.207
16	0.05	27.61	0.869	0.200	00:05
	0.10	27.69	0.871	0.195
	0.20	27.61	0.872	0.191

Appendix

Table A6: Sensitivity to the selection threshold

\tau

on MatrixCity-SmallCity.

T_{\text{partition}}

is reported in

hh

mm

Panel of Figure 20 — Figure A4 : Partition time of the three camera selection strategies. All three scale linearly in camera count.

Dataset	Coarse Iter.	Coarse				Fine
Dataset	Coarse Iter.	PSNR	SSIM	LPIPS	#GS	PSNR	SSIM	LPIPS	#GS
SmallCity	10k	23.32	0.668	0.491	5.6	27.80	0.874	0.186	27.9
	20k	24.55	0.730	0.414	8.8	27.71	0.873	0.186	28.5
	30k	25.27	0.765	0.368	13.6	27.69	0.875	0.185	28.9
Building	10k	18.93	0.628	0.396	4.5	21.89	0.788	0.234	14.0
	20k	19.86	0.682	0.348	6.7	21.97	0.789	0.233	13.6

Appendix

Table A7 : Sensitivity of LoBE-GS to the quality of the coarse 3DGS prior. We vary the number of coarse training iterations and report both coarse and final LoBE-GS reconstruction metrics on three datasets. #GS is the number of Gaussians in millions.

Figure A5 : Visualization of the block partition and corresponding worst-block fine-stage runtime for CityGS, LoBE-GS w/o cut refinement (CR), and full LoBE-GS on five datasets: Building, Rubble, Residence, Sci-Art, and MatrixCity-SmallCity.

Scene	Camera Pose	Bil. Grid	PSNR	SSIM	LPIPS	CC-PSNR	CC-SSIM	CC-LPIPS	#GS (M)
Building	Original	✗	22.13	0.790	0.231	22.97	0.786	0.235	13.9
	COLMAP	✗	22.73	0.827	0.194	23.61	0.822	0.198	12.8
	COLMAP	✓	20.27	0.808	0.193	22.95	0.818	0.191	14.3
Rubble	Original	✗	25.93	0.813	0.232	26.65	0.813	0.232	9.2
	COLMAP	✗	27.45	0.888	0.164	28.10	0.887	0.164	11.9
	COLMAP	✓	23.05	0.877	0.162	27.74	0.894	0.155	13.3

Appendix

Table A8: Quantitative result under different camera pose sources and appearance modeling. Pose indicates whether the camera poses distributed with the dataset ( Original ) or our re-estimated poses ( COLMAP ) are used; Bil. Grid indicates the bilateral grid appearance module. CC denotes color-corrected metrics; best value per scene and metric in bold .

Figure A6 : Qualitative comparison under different camera pose sources and appearance modeling. Insets show magnified crops of the boxed regions. Renders using the original camera poses exhibit blurry artifacts on high-frequency structure, while the bilateral grid reduces low-frequency color blotching.

3D Gaussian Splatting

3D Gaussian Splatting represents scenes as optimizable 3D Gaussian primitives for fast, photorealistic rendering from new viewpoints.

See all 1,019 papers

May 13, 2026

BlitzGS: City-Scale Gaussian Splatting at Lightning Speed

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.

Zhongtao Wang, Huishan Au, Yilong Li +6

Peking University, China

3D Gaussian Splatting 3D Gaussian Pruning 3DGS Acceleration GPU Acceleration 3D Reconstruction Gaussian Splatting

Ask PDF

Jun 17, 2026

Splaxel: Efficient Distributed Training of 3D Gaussian Splatting for Large-scale Scene Reconstruction via Pixel-level Communication

3D Gaussian Splatting (3DGS) enables high-fidelity and real-time 3D scene reconstruction, but scaling training to large-scale scenes requires optimizing hundreds of millions of Gaussians across multiple GPUs. Existing distributed approaches either partition scenes into isolated regions, causing global inconsistency, or rely on global Gaussian-level exchanges, which lead to substantial growth in inter-GPU communication and quickly dominate iteration time. We propose Splaxel, a communication-efficient distributed 3DGS training framework based on pixel-level local rendering and global composition. Instead of synchronizing Gaussians, each GPU renders its local subset and exchanges only partial pixel values, maintaining mathematical consistency while keeping communication cost stable as the scene size increases. Splaxel further reduces pixel-level redundancy through geometric and transmittance visibility prediction and improves GPU utilization via conflict-free camera-view consolidation. Evaluated on large-scale datasets with up to 120M Gaussians, Splaxel achieves up to 7.6

\times

speedup over the state-of-the-art distributed 3DGS framework while preserving high reconstruction quality.

Wenqi Jia, Zhewen Hu, Ying Huang +10

UT Arlington · Texas A&M University · Independent Researcher +5

3D Gaussian Splatting 3DGS Acceleration Communication-Efficient Distributed Training 3D Reconstruction

Ask PDF

Mar 25, 2026

FilterGS: Traversal-Free Parallel Filtering and Adaptive Shrinking for Large-Scale LoD 3D Gaussian Splatting

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

Yixian Wang, Haolin Yu, Jiadong Tang +4

Beijing Institute of Technology

3D Gaussian Splatting 3DGS Acceleration

Ask PDF

Abstract

3D Gaussian Splatting

Explore similar work

BlitzGS: City-Scale Gaussian Splatting at Lightning Speed

Splaxel: Efficient Distributed Training of 3D Gaussian Splatting for Large-scale Scene Reconstruction via Pixel-level Communication

FilterGS: Traversal-Free Parallel Filtering and Adaptive Shrinking for Large-Scale LoD 3D Gaussian Splatting