betaFeedback

WorksComputer Science

DOOM-GS: Dynamic Out-of-core Optimization for Massive Gaussian Splatting

Abstract

Traditional Gaussian Splatting (GS) methods use in-core training, i.e. assuming that GPU memory is large enough to accommodate all the primitives. This assumption breaks down when the primitives exceed the capacity of GPU memory, e.g. GS on large environments. Recent out-of-core training research starts to address this issue, but is limited to static scenes. Unlike static GS, dynamic GS primitives move in space and time, breaking common assumptions held in existing out-of-core research and impose new challenges in memory management and training. To this end, we propose Dynamic Out-of-core Optimization for Massive Gaussian Splatting (DOOM-GS), the first out-of-core optimization method designed specifically for massive-scale dynamic GS. DOOM-GS is equipped with novel memory management strategies that optimize caching for spatio-temporal primitives, and a fast learning method for large numbers of primitives. Due to the lack of suitable datasets for large-scale dynamic GS, we also contribute a new dataset for evaluation. Since there are no directly comparable methods, we adapt several closely related methods for comparison. Through extensive evaluation, we demonstrate the effectiveness of DOOM-GS which now makes it possible to reconstruct city-scale dynamic scenes with high quality on moderate hardware, serving as a foundational tool for diverse future research and applications.

Introduction

Gaussian Splatting (GS) has become a foundational component of tools for graphics [9, 14, 34], robotics [8, 25, 32], medical imaging [13, 27, 36], etc. Given its universal importance, recent research has attempted to fundamentally improve GS’ capabilities with more flexible representations [5, 18, 26, 29, 40], improved optimization processes [10, 22, 23], and incorporated data uncertainty [7, 12, 37]. Being orthogonal to all these attempts, a fundamental compromise in GS is the number of primitives versus the difficulty of training. Generally, more primitives lead to higher quality but require more computation, larger memory consumption, and thus longer and brittle training. Furthermore, since most training methods require full GPU residency of all primitives, it puts a significant constraint on the number of primitives.

To address this, recent out-of-core methods have enabled GS training on large static scenes by dynamically transferring primitives between GPU, CPU, and storage [30, 38, 39]. However, extending this capability to dynamic scenes is substantially more challenging, as motion and finite temporal support of components violate two key assumptions of existing methods. First, existing methods exploit static spatial locality, meaning that Gaussians that are close in 3D space are stored or transferred together and are expected to remain together throughout training [30, 38, 39]. In contrast, Gaussians in dynamic scenes move and remain active only over finite temporal intervals, causing static spatial groupings to lose locality over time and thereby violating this assumption. Second, the primitives visible from a single view may already exceed the GPU memory, breaking the assumption that GPU memory can accommodate primitives across views for resident blocks re-use [38, 39]. A new approach addressing these two challenges is needed.

To enable dynamic GS on large scenes, we propose Dynamic Out-of-Core Optimization for Massive Gaussian Splatting (DOOM-GS), which is the first dynamic out-of-core GS training framework to the best of our knowledge. DOOM-GS addresses the first challenge by maintaining compact space-time blocks, in contrast to spatial blocks in existing research [30, 38, 39], via a series of bespoke operations. In addition, it employs overlapping-aware camera scheduling to reduce data transfers while preserving camera and temporal diversity for stable training. Second, to remove the per-view memory constraint of existing methods, we propose a fast learning approach by augmenting an inference-only method Gaussian Point Splatting (GPS) [21] into a learnable model, relaxing the constraint imposed by GPU on the number of primitives associated with a view.

Evaluation is also challenging because no existing method directly supports massive dynamic out-of-core training, and no public benchmark combines dynamic content, dense multi-view observations, and large-scale coverage. Therefore, we introduce DynamicMatrixCity, a new dataset based on MatrixCity [16] containing dynamic objects. We also adapt the closest out-of-core methods for static scenes as baselines. Our experiments demonstrate that DOOM-GS enables high-quality city-scale dynamic reconstruction under bounded GPU memory while improving temporal consistency and training efficiency. Our contributions are:

  • DOOM-GS, the first dynamic out-of-core GS training framework for massive dynamic scenes.

  • A new data block management strategy and camera scheduling for efficient data transfer.

  • A new learnable rendering process, allowing learning from views where the primitives associated with a single view are too large to fit in GPU memory.

  • A new dataset DynamicMatrixCity, a city-scale multi-view dataset for out-of-core dynamic GS.

Related Work

Dynamic Gaussian Splatting. Most dynamics GS methods differ mainly in their representations of motion. 3D Gaussians can be mapped to different timesteps [28, 31, 33]. Alternatively, spatio-temporal behaviors can be explicitly encoded into primitives. They can be directly optimized over space and time [6, 35], or parameterized by polynomial functions [17, 26]. The dynamics of Gaussians can be limited to a short temporal support [29] to reduce redundancy. High-order dynamics can improve the modeling of complex motions [37]. Our work is orthogonal to this research and adopts the explicit space-time representation and focuses on scaling its optimization to massive dynamic scenes.

Out-of-Core Optimization. Unlike conventional GS methods, recent out-of-core training methods can optimize large GS scenes on moderate GPUs [30, 38, 39]. CLM-GS [38] offloads Gaussian parameters to CPU memory while overlapping data transfer with GPU computation. TideGS [39] introduces an SSD–CPU–GPU hierarchy with asynchronous streaming and prefetching, while A LoD of Gaussians [30] combines out-of-core training with a level-of-detail representation. These methods partition the model into fixed-size blocks enabling efficient contiguous transfers and shifts the model-size limit from GPU memory to storage. However, they target static scenes and remain limited by storage traffic, poor spatial and temporal block locality, and gradient computation restricted to GPU-resident Gaussians. DOOM-GS extends this paradigm to dynamic scenes while addressing these limitations.

Rendering Beyond GPU Memory. Despite advances in out-of-core training for GS, existing methods still face two key challenges. They either rely on complex hierarchical level-of-detail structures [3, 24, 30] or cannot process views where the visible Gaussians exceed GPU memory capacity. To this end, various rendering methods have been proposed to render scenes that contain more components than the GPU memory limit. StochasticSplats [11] is one of the first works to propose sort-free rendering of scenes by leveraging stochastic rasterization and an unbiased Monte Carlo estimator of the rendering equation. Although this is not explicitly designed to address the GPU memory limit, it enables processing the alpha blending in parts by eliminating the need for sorting. Following this, Gaussian Point Splatting [21] proposed a stochastic rendering method that samples pixel-sized opaque points from Gaussians and splats them independently, enabling scalable rendering of scenes beyond GPU memory limits. However, it is only for forward rendering and cannot be used for learning. We turn it into a learnable process, enabling learning from views where associated Gaussians are too big for GPU.

Large-Scale Datasets. Capturing large multi-view dynamic scenes for benchmarking GS methods remains challenging. Existing benchmarks are generally either large-scale but static [16] or dynamic but limited in scene size and camera coverage [1, 15, 20]. Furthermore, acquiring large-scale real-world data requires dense arrays of synchronized and calibrated cameras over large areas, while raising substantial logistical, storage, and privacy concerns. Consequently, synthetic environments remain the most practical option for generating city-scale dynamic observations. MatrixCity [16] provides full-city scenes at multiple scales, but its publicly released data contain only static content.

Methodology

Preliminaries

Component Dynamics. Dynamic GS makes each Gaussian component time-dependent, allowing a single model to represent a dynamic scene. We follow [37], where each component GiG_i is parameterized by θi\theta_i, comprising its mean μi\mu_i, covariance Σi\Sigma_i, opacity oio_i, color shish_i, appearance time gig_i, duration uiu_i, and motion parameters {vi,ai,ji,si}\{\mathbf{v}_i,\mathbf{a}_i,\mathbf{j}_i,\mathbf{s}_i\}, representing velocity, acceleration, jerk, and snap. At normalized time t∈[0,1]t \in[0,1], its mean and opacity are

μi(t)=μi+fi(t),oi(t)=oiexp⁡(−(t−gi)22ui2)\mu_i(t)=\mu_i+f_i(t),\quad o_i(t)=o_i\exp\left(-\frac{(t-g_i)^2}{2u_i^2}\right)

where

fi(t)=viΔt+ai2Δt2+ji6Δt3+si24Δt4.(1)f_i(t)=\mathbf{v}_i\Delta t+\frac{\mathbf{a}_i}{2}\Delta t^2+\frac{\mathbf{j}_i}{6}\Delta t^3+\frac{\mathbf{s}_i}{24}\Delta t^4. \tag*{(1)}

Δt\Delta t is the time step size. gig_i and uiu_i jointly control the temporal change of opacity of each component. Covariance and color remain fixed in time. Finally, each frame is rendered from the moving and time-parameterized Gaussians.

Point Splatting. Standard GS renders Gaussians using depth-ordered alpha compositing. GPS [21] instead represents each projected Gaussian with independently sampled opaque points and retains the nearest point at each subpixel through an atomic depth test. We adopt this renderer because its order-independent formulation does not require all visible Gaussians to reside in GPU memory simultaneously for sorting. Let oi(q)o_i(q) denote the opacity of Gaussian ii at subpixel qq, and let λi(q)\lambda_i(q) be the expected number of points it generates at that location. For a Poisson process with rate λi(q)\lambda_i(q), the probability of generating no point is e−λi(q)e^{-\lambda_i(q)}. Matching this probability to the Gaussian transparency 1−oi(q)1-o_i(q) gives

e−λi(q)=1−oi(q),λi(q)=−ln⁡(1−oi(q)).(2)e^{-\lambda_i(q)} = 1-o_i(q), \qquad\lambda_i(q)=-\ln(1-o_i(q)). \tag*{(2)}

Thus, Gaussian ii generates at least one point at qq with probability oi(q)o_i(q). A point from Gaussian ii is visible only if no Gaussian in front of it generates a point at the same subpixel. The corresponding transmittance is

Ti(q)=∏j in front of i(1−oj(q)).(3)T_i(q)=\prod_{j\ \mathrm{in\ front\ of}\ i}(1-o_j(q)). \tag*{(3)}

Gaussian ii therefore provides the nearest point with probability oi(q)Ti(q)o_i(q)T_i(q), matching its weight in standard alpha compositing. Consequently, the expected point-splatting image approximates the standard GS image.

DOOM-GS

DOOM-GS trains massive dynamic GS models on a single 24 GB GPU using standard CPU memory and SSD storage. As illustrated in Figure 1, Gaussians are stored in fixed-size SSD blocks, frequently accessed blocks are cached in CPU memory, and only blocks visible to the current camera batch are loaded onto the GPU. Moving out-of-core training from static to dynamic scenes raises three challenges. First, Gaussians move and exist only for finite time spans, so blocks based on purely spatial grouping quickly lose their locality. Next, the visible set of Gaussians changes with both the camera and time. Last, a single view of a large scene can already involve Gaussians exceeding the capacity of GPU memory. DOOM-GS addresses these challenges with space-time-aware block organization, overlap-aware camera scheduling for block reuse, and chunked point splatting with gradient estimators.

DOOM-GS overview showing block management and camera scheduling

Figure 1. DOOM-GS overview. Left: Gaussians are stored on SSD in fixed-size blocks, with frequently accessed blocks cached in CPU memory. A block enters the dynamic working set K(C)\mathcal{K}(C) when its motion-aware bounding sphere of radius RkR_k is spatially visible and the camera timestamp lies within its temporal support SkS_k as in Equation (8). Green and orange blocks are selected by one camera, dark blue blocks by both, and hollow blocks by neither due to spatial or temporal culling. Right: Each scheduling pass selects one view from every camera. The next unused camera maximizes J(c,c′)J(c,c'), and its least-used frame is selected with ties resolved by proximity to tft_f.

Block Storage for Dynamic Gaussians

Similar to TideGS [39], we store the NN Gaussians in fixed-size blocks containing B=4096B=4096 records. This results in Kblk=N/BK_{\mathrm{blk}}=N/B blocks. We index the blocks by k∈{1,…,Kblk}k\in\{1,\ldots,K_{\mathrm{blk}}\} and denote the set of Gaussians stored in block kk by B(k)\mathcal{B}(k). All blocks are stored on SSD in an out-of-core structure that we refer to as the block store. Each record stores 59 static parameters, comprising its 3D mean μi\boldsymbol{\mu}_i, covariance Σi\boldsymbol{\Sigma}_i, opacity oio_i, and spherical-harmonic coefficients shi\mathbf{sh}_i. An additional 14 parameters describes its dynamics through the temporal center gig_i, temporal scale uiu_i, and four 3D motion coefficients {vi,ai,ji,si}\{\mathbf{v}_i,\mathbf{a}_i,\mathbf{j}_i,\mathbf{s}_i\}. Each block kk is represented by a bounding sphere with center and radius (ck,rk)(\mathbf{c}_k,r_k) that encloses the means of all Gaussians in that block. Given a batch of cameras C\mathcal{C}, the system loads a block if its bounding sphere intersects the viewing frustum of at least one camera in the batch. However, this spatial criterion alone is insufficient for dynamic Gaussians whose means vary over time and whose contributions are limited to finite temporal intervals. We therefore extend block-level culling to jointly account for spatial visibility and temporal activity. Let ϵ\epsilon denote the minimum opacity that we consider significant. For a Gaussian temporal profile in Equation (1), the opacity decreases with the distance from its temporal center. The factor κ=−2ln⁡ϵ\kappa=\sqrt{-2\ln\epsilon} gives the distance, in units of temporal scale, at which the opacity reaches ϵ\epsilon. We therefore consider Gaussian ii active when ∣t−gi∣≤κui|t-g_i|\leq\kappa u_i. For block kk, we define a common temporal margin

Δk=max⁡i∈B(k)κui.(4)\Delta_k=\max_{i\in\mathcal{B}(k)}\kappa u_i. \tag*{(4)}

The temporal support of the block is then

Sk=[min⁡i∈B(k)gi−Δk, max⁡i∈B(k)gi+Δk].(5)S_k=\left[\min_{i\in\mathcal{B}(k)}g_i-\Delta_k,\ \max_{i\in\mathcal{B}(k)}g_i+\Delta_k\right]. \tag*{(5)}

This interval is the union of the active periods of all Gaussians in block kk. We additionally account for the motion of each Gaussian within its temporal support and denote the temporal support radius of Gaussian ii by δi=κui\delta_i=\kappa u_i. We use δi\delta_i as the maximum distance in time from the temporal center gig_i within which Gaussian ii is considered active. Using δi\delta_i, we can derive the maximum displacement in space by

ρi=∥vi∥δi+∥ai∥2δi2+∥ji∥6δi3+∥si∥24δi4.(6)\rho_i=\|\mathbf{v}_i\|\delta_i+\frac{\|\mathbf{a}_i\|}{2}\delta_i^2+\frac{\|\mathbf{j}_i\|}{6}\delta_i^3+\frac{\|\mathbf{s}_i\|}{24}\delta_i^4. \tag*{(6)}

where ρi\rho_i is the maximum displacement of Gaussian ii within its temporal support. We extend the bounding sphere of each block by the largest ρi\rho_i among its Gaussians:

Rk=rk+max⁡i∈B(k)ρi.(7)R_k=r_k+\max_{i\in\mathcal{B}(k)}\rho_i. \tag*{(7)}

For a camera batch C\mathcal{C}, the dynamic working set is

K(C)={k∣∃c∈C:tc∈Sk∧visible⁡(ck,Rk,c)}.(8)\mathcal{K}(\mathcal{C})=\{k\mid\exists c\in\mathcal{C}:t_c\in S_k\land\operatorname{visible}(\mathbf{c}_k,R_k,c)\}. \tag*{(8)}

where tct_c is the timestamp of camera cc, and visible tests whether the block’s bounding sphere intersects the camera frustum. A block is loaded into GPU memory if it is temporally active and visible for at least one camera in C\mathcal{C}.

The rendering and optimization speed of this scheme depends on blocks remaining compact in both space and time. Existing out-of-core GS methods use different forms of spatial organization and model growth. TideGS [39] partitions Morton-ordered Gaussians into fixed spatial blocks and, in its large-scale setting, relies on a dense initialization without training-time densification or relocation. CLM-GS [38] supports standard adaptive densification, while A LoD of Gaussians [30] grows and restructures a spatial Gaussian hierarchy through leaf spawning and respawning.

However, all three methods organize Gaussian access using only spatial information and do not account for temporal support or motion. Their direct extension to dynamic scenes may therefore load temporally inactive Gaussians and lose spatial locality as Gaussian positions evolve. This is particularly limiting in dynamic regions, where incomplete initialization and Gaussian motion reduce block compactness. Spatial-only grouping may place Gaussians with substantially different lifetimes in the same block, enlarging block temporal support and weakening temporal culling.

To address these limitations, DOOM-GS updates both the Gaussian population and the block layout during training, with several operations. Cloning increases the model capacity, relocation reuses inactive slots, and periodic repacking restores block compactness using 4D Morton ordering. Cloning and relocation are performed during the densification phase and operate on the Gaussians in the current working set K(C)\mathcal{K}(C). For Gaussian ii, ∇μiL\nabla_{\mu_i}\mathcal{L} denotes the gradient of the current batch loss with respect to its 3D mean μi\mu_i. Each Gaussian is assigned the score

si=12(∥∇μiL∥2max⁡j∈K(C)∥∇μjL∥2+oi).(9)s_i = \frac{1}{2}\left(\frac{\lVert\nabla_{\mu_i}\mathcal{L}\rVert_2}{\max_{j\in\mathcal{K}(C)}\lVert\nabla_{\mu_j}\mathcal{L}\rVert_2}+o_i\right). \tag*{(9)}

Targets for both operations are sampled in proportion to sis_i. This score favors Gaussians with large 3D position gradients and high opacity.

Cloning. Cloning grows the model toward Nmax⁡N_{\max}. Source Gaussians are sampled in proportion to sis_i, and their opacity and scale are split between the source and its copies following 3DGS-MCMC [10]. Each clone inherits the source’s temporal and motion parameters. The clones are then sorted by their 4D Morton codes and appended to the store.

Relocation. Relocation reuses inactive Gaussian slots instead of pruning them, keeping the model size fixed. A Gaussian is considered inactive if its opacity falls below 0.005, or if its opacity remains below 0.01 and its 3D mean μi\mu_i receives no position gradient for 2,000 iterations. Its slot is reassigned to a target sampled using sis_i, provided that the opacity of every resulting copy remains at least 0.01. To preserve spatial locality, each target reuses a dead Gaussian slot from the Morton cell with an available slot. The relocation is performed only if the dead Gaussian’s position is within one median block diameter of the target. At most 5% of the working set is relocated per step.

Repacking. Cloning and relocation do not fully preserve block compactness, as clones may originate from distant regions and repeated relocation can degrade spatial locality. We repacks the store every 2,000 iterations by reordering all Gaussians and rewriting them into full blocks. A 4D Morton code over the normalized 3D means and temporal centers groups Gaussians that are close in space and time. To avoid mixing substantially different lifetimes, Gaussians active for at least half of the sequence are packed using spatial Morton ordering. The remaining Gaussians are divided into four duration classes with successively halved ranges and ordered within each class using a 4D Morton code with class-normalized temporal coordinates.

Camera Scheduling for Dynamic Gaussians

One major factor of training speed is how often we can reuse blocks that are already resident in GPU memory. Since training is conducted on a series of data batches, consecutive batches with similar working sets require fewer new block transfers and are therefore processed more efficiently. A dynamic capture contains M×KM \times K views (c,f)(c,f), where cc is the camera and ff is the frame at time tft_f. Random ordering provides little reuse between batches. CLM-GS [38] optimizes the order only within each batch, whereas TideGS [39] orders views by camera pose. For videos from stationary cameras, this repeatedly selects the same camera at different frames, reducing viewpoint diversity and harming optimization and image quality.

DOOM-GS instead uses a global greedy scheduling strategy illustrated in Figure 1. We discretize the scene into a voxel grid and let VcV_c denote the occupied voxels intersecting the viewing frustum of camera cc. The overlap between cameras cc and c′c' is measured by the Jaccard similarity J(c,c′)J(c,c') of their voxel sets. Scheduling proceeds in passes, with each camera selected exactly once per pass. Given the current view (c,f)(c,f), we select the unused camera c′c' that maximizes J(c,c′)J(c,c'). We then select its least-used remaining frame, breaking ties by choosing the timestamp closest to tft_f. The resulting sequence is divided into batches. This schedule increases block reuse between consecutive batches, avoids repeated updates from the same camera, and distributes training views across the full sequence.

Point Splatting with Gradient Estimators

Even with block streaming, 3DGS rasterization requires all visible Gaussians to be in the GPU for sorting and alpha compositing, which often exceeds GPU memory already. We therefore employ the sort-free method GPS [21]. However, GPS is designed only for forward rendering, therefore, we propose a gradient estimator for learning. At subpixel qq, GPS computes the color I(q)I(q) using the nearest sampled point (see § 3.1). This rendering process converges to the alpha compositing in expectation. Indexing Gaussians front to back along a view ray, we partition this expectation around Gaussian ii as

E[I(q)]=∑j<iTj(q)oj(q)shj(q)+Ti(q)oi(q)shi(q)+∑i<kTk(q)ok(q)shk(q)(10)\mathbb{E}[I(q)] = \sum_{j<i} T_j(q)o_j(q)sh_j(q) + T_i(q)o_i(q)sh_i(q) + \sum_{i<k} T_k(q)o_k(q)sh_k(q) \tag*{(10)}

The original GPS can be seen as a one-point Monte Carlo approximation of this expectation. The first term is not a function of oi(q)o_i(q) and shi(q)sh_i(q), while the second term is a function of both. The third term is a function of oi(q)o_i(q):

Tk(q)=(1−oi(q))Ti(q)∏i<n<k(1−on(q)).(11)T_k(q) = (1-o_i(q))T_i(q)\prod_{i<n<k}(1-o_n(q)). \tag*{(11)}

The factor Bik(q)B_{ik}(q) is independent of oi(q)o_i(q). Substituting Equation (11) into the third term of Equation (10) allows the common factor Ti(q)(1−oi(q))T_i(q)(1-o_i(q)) to be taken outside the sum. The remaining term that will influence the gradient later defines the expected color behind Gaussian ii is

cˉi b(q)=∑k>i[∏i<n<k(1−on(q))]ok(q)shk(q).(12)\bar{c}_i^{\,b}(q)=\sum_{k>i}\left[\prod_{i<n<k}(1-o_n(q))\right]o_k(q)sh_k(q). \tag*{(12)}

Therefore, differentiating the third term in Equation (10) gives

∂∂oi(q)[∑k>iTk(q)ok(q)shk(q)]=∑k>i−Bik(q)ok(q)shk(q)=−Ti(q)cˉi b(q).(13)\frac{\partial}{\partial o_i(q)}\left[\sum_{k>i}T_k(q)o_k(q)sh_k(q)\right] = \sum_{k>i}-B_{ik}(q)o_k(q)sh_k(q) = -T_i(q)\bar{c}_i^{\,b}(q). \tag*{(13)}

Combining this with the contribution of the second term in Equation (10), and using the image-space gradient g(q)=∂L/∂I(q)g(q)=\partial\mathcal{L}/\partial I(q), gives

∂L∂shi(q)=oi(q)Ti(q)g(q),\frac{\partial\mathcal{L}}{\partial sh_i(q)}=o_i(q)T_i(q)g(q),
∂L∂oi(q)=Ti(q)g(q)(shi(q)−cˉi b(q)).(14)\frac{\partial\mathcal{L}}{\partial o_i(q)}=T_i(q)g(q)\left(sh_i(q)-\bar{c}_i^{\,b}(q)\right). \tag*{(14)}

One challenge for the gradient estimator is estimating cˉi b(q)\bar{c}_i^{\,b}(q), which requires all the Gaussians behind Gaussian ii and is infeasible at scale. We propose a feasible approximation. The original 3DGS rasterizers obtain this quantity through ordered alpha compositing, whereas GPS retains no depth-sorted list and therefore cannot compute cˉi b(q)\bar{c}_i^{\,b}(q) directly. To estimate this color, we use a framebuffer for each subpixel shown in Figure 2. The framebuffer stores the nearest and the second nearest point at each subpixel. When Gaussian ii is visible, the second entry gives the color c2(q)c_2(q) that would be visible if points from ii were removed. Independent point sampling gives E[c2(q)∣i is visible]=cˉi b(q)\mathbb{E}[c_2(q)\mid i\text{ is visible}]=\bar{c}_i^{\,b}(q), so c2(q)c_2(q) is unbiased when ii is visible.

Figure 2. Point-splatting gradients at subpixel qq. The depth expansion shows the transmittance Ti(q)T_i(q), opacity oi(q)o_i(q), and expected color cˉi b(q)\bar{c}_i^{\,b}(q) behind Gaussian ii. The framebuffer stores the visible point and the nearest point from a different Gaussian, whose color c2(q)c_2(q) estimates the color behind ii.

During the backward pass, we regenerate the same point samples and replay them against the completed framebuffer. The depth test indicates whether Gaussian ii is visible in

GPS, while c2(q)c_2(q) samples the color behind it. The supplementary material provides the complete derivation and additional details. Gradients of the remaining Gaussian parameters follow through the standard projection chain rule.

Streaming. For each batch, we partition the working set into chunks that fit in GPU memory. During the forward pass, the chunks are rendered sequentially into a separate framebuffer for each camera. After all chunks are processed, we compute the rendered images, loss, and image-space gradients, retaining only the frame buffers and image gradients. During the backward pass, each chunk is reloaded once, and its point samples are regenerated and replayed against all camera framebuffers. The resulting gradients are accumulated across cameras, after which the Gaussian parameters are updated, written back to the block store, and released. Since only one chunk and fixed-size per-camera buffers reside on the GPU, peak memory is independent of the number of Gaussians visible in a view.

Experiments

Experimental Setting

Baselines. Existing out-of-core Gaussian-splatting methods primarily target static scenes. We therefore evaluate DOOM-GS in two complementary comparison settings. First, we construct a dynamic variant of TideGS [39] by replacing its static primitives with the GraphiXS [37] dynamic representation while retaining its out-of-core framework, yielding a baseline with the same representation as ours. Second, we train CLM-GS [38], TideGS [39], and A LoD of Gaussians [30] independently for each frame. Together, these settings compare DOOM-GS against both a dynamic extension of an existing method and per-frame static reconstruction approaches.

Dataset. MatrixCity [16] is widely used for large-scale static reconstruction but provides no public dynamic scenes, so we extend its Small City map with procedurally generated pedestrians and vehicles while retaining the original camera poses. The resulting DynamicMatrixCity dataset contains three scenes of increasing scale, namely Corner (80 m×80 m80\,\mathrm{m} \times80\,\mathrm{m}), Block (260 m×150 m260\,\mathrm{m} \times150\,\mathrm{m}), and District (1,870 m×1,500 m1{,}870\,\mathrm{m} \times1{,}500\,\mathrm{m}). Each camera records 120 frames at 30 fps and 1920×10801920 \times1080 resolution. We hold out 12 cameras in Corner and 64 in each of Block and District, excluding all corresponding frames from training; further details are provided in the supplementary material.

Metrics. We report PSNR, SSIM, and LPIPS. We measure data reuse using the GPU hit rate, defined as the fraction of block access served by blocks already resident in GPU memory. For per-frame baselines, we additionally report flicker, which measures unwanted temporal changes in regions that remain static in the ground truth. Training efficiency is measured by wall-clock time excluding evaluation, summed over all frame models for per-frame baselines.

Native Dynamic Comparison

We compare DOOM-GS with Dynamic TideGS on the three DynamicMatrixCity scenes. Both methods optimize a single 20M-Gaussian model over the full 120-frame sequence, starting from the same initial point cloud and using the same dynamic Gaussian representation, learning rates, and densification schedule. We train with batches of four images for 40K iterations on Corner and Block, and for 200K iterations on District. Both methods use a 1,800-block GPU budget, equivalent to 7.4M Gaussians, with peak GPU memory below 20 GB. Table 1 reports the quantitative results, and Figure 3 presents qualitative comparisons. DOOM-GS substantially improves reconstruction quality across all three scenes. It increases PSNR by 9.3 dB on Corner, 13.9 dB on Block, and 9.2 dB on District. The improvements are consistent across the remaining metrics. LPIPS decreases from 0.570 to 0.293 on Corner, while SSIM increases from 0.344 to 0.721 on Block and from 0.286 to 0.658 on District. The qualitative comparisons in Figure 3 similarly show cleaner street-level and aerial renderings. DOOM-GS also improves the GPU hit rate, reaching 89% on Block compared with 78% for Dynamic TideGS. It reduces training time by 46% on Corner, 31% on Block, and 28% on District. Peak GPU memory is similar on Corner, while DOOM-GS reduces it from 18.9 to 16.8 GB on Block and from 20.5 to 12.6 GB on District.

Qualitative comparison of ground-truth, Dynamic TideGS, and DOOM-GS results for street-level and aerial cameras

Figure 3. Qualitative comparison on held-out street-level and aerial views from Corner, Block, and District. Dynamic TideGS exhibits streaking and haze, whereas DOOM-GS better preserves scene structure and detail. C and F denote the camera and frame indices, respectively, and per-image PSNR are shown.

MethodPSNR↑\uparrowSSIM↑\uparrowLPIPS↓\downarrowHit↑\uparrowMem.↓\downarrowTime↓\downarrow
Corner
Dyn. TideGS15.600.5150.57078%18.029.5
DOOM-GS (Ours)24.930.8240.29379%18.815.9
Block
Dyn. TideGS9.280.3440.68778%18.954.2
DOOM-GS (Ours)23.190.7210.44789%16.837.2
District
Dyn. TideGS10.190.2860.72475%20.5317.4
DOOM-GS (Ours)19.350.6580.53486%12.6228.5

Table 1. Comparison on DynamicMatrixCity. Image-quality metrics are averaged over all frames of all held-out cameras. GPU hit rate is averaged over training. Memory is the peak GPU memory allocated during training in GB; time is training hours.

The trajectory-based ordering of TideGS targets static multi-view captures and is not designed for stationary multi-camera videos. Because all 120 frames from each camera share the same pose, Dynamic TideGS schedules them consecutively, reducing viewpoint diversity and visiting only 1,334 of 4,032 training cameras on Block after 40K iterations. In contrast, DOOM-GS selects each camera once per pass, covering all training cameras every 1,008 iterations on Block and 2,032 iterations on District, thereby providing more balanced spatial and temporal supervision.

Dynamic TideGS renders each view using only the visible blocks that fit within its 1,800-block GPU budget. Coverage is initially 100% because the complete model fits, but append-only densification and relocation reduce block locality as the model grows. Near the end of training, a view contains around 4,800 of the 4,883 blocks, so only about 37% of its visible blocks are selected on the GPU, yielding 43–48% average coverage across the three scenes. These incomplete renderings produce inconsistent gradients and the streaking and haze visible in Figure 3. DOOM-GS maintains 100% coverage by streaming all visible blocks through point splatting, so the GPU budget bounds only simultaneous residency, not the number of primitives rendered per

view. Its space-time block organization also preserves locality, reducing the visible set on Block to approximately 2,000 blocks per view and increasing the GPU hit rate from 78% to 89%.

Per-frame Dynamic Experiments

We compare DOOM-GS with per-frame optimized TideGS [39], CLM-GS [38], and A LoD of Gaussians [30] on Corner and Block. Each baseline treats the 120 frames as independent static scenes and trains one 2.5M-Gaussian model per frame for 5K iterations. We could not use District as the required GPU memory for the baseline methods would be impractically large. DOOM-GS instead trains one 2.5M-Gaussian dynamic model over the complete sequence for 40K iterations. All methods use batches of four images and at most 300 resident blocks.

Tables Table 2 and Table 3 report reconstruction quality and resource cost. On Block, DOOM-GS achieves the best PSNR, SSIM, and LPIPS, improving PSNR by 1.3 dB over the strongest per-frame baseline and 3.5 dB over TideGS. On Corner, CLM-GS achieves 0.37 dB higher PSNR, while DOOM-GS obtains the best SSIM and LPIPS. Compared with the most stable baseline, DOOM-GS reduces flicker by 7.1× on Corner and 6.3× on Block. Figure 4 shows qualitative trends for street-level and aerial views.

Qualitative comparison of ground-truth and rendered street-level and aerial views from Corner and Block

Figure 4. Qualitative comparison on held-out street-level and aerial views from Corner and Block. Each baseline uses a static model trained for the shown frame, whereas DOOM-GS uses one dynamic model trained over the complete sequence. C and F denote the camera and frame indices, respectively, and per-image PSNR are shown.

MethodPSNR↑\uparrowSSIM↑\uparrowLPIPS↓\downarrowFlicker↓\downarrow
Corner
TideGS22.110.7440.43029.18
CLM-GS25.700.8300.31425.73
A LoD of Gaussians24.040.7890.38419.84
DOOM-GS (Ours)25.330.8370.3082.79
Block
TideGS19.500.5880.61336.64
CLM-GS21.320.6700.52650.96
A LoD of Gaussians21.690.6620.54718.24
DOOM-GS (Ours)23.020.7120.4772.89

Table 2. Reconstruction quality and temporal consistency. Metrics are averaged over all frames of all held-out cameras. Flicker is reported in units of 10−310^{-3}.

MethodTotal Gauss.↓Mem.↓Time↓
Corner
TideGS300M2.671.4
CLM-GS300M1.520.0
A LoD of Gaussians300M1.554.7
DOOM-GS (Ours)2.5M2.422.9
Block
TideGS300M2.476.0
CLM-GS300M1.630.6
A LoD of Gaussians300M1.543.9
DOOM-GS (Ours)2.5M2.314.5

Table 3. Cost of reconstructing the complete 120-frame sequence. Per-frame methods store 120 independent models. Mem. is the peak GPU memory, time is the training time summed over all frames, in hours.

DOOM-GS represents the complete sequence with one 2.5M-Gaussian model, compared with 120 per-frame models containing 300M Gaussians in total. On Corner, it is 3.1× faster than TideGS and 2.4× faster than A LoD of Gaussians, while CLM-GS is slightly faster at 20.0 hours compared with 22.9 hours. On Block, DOOM-GS is the fastest method, outperforming TideGS, CLM-GS, and A LoD of Gaussians by 5.2×, 2.1×, and 3.0×, respectively. Per-frame optimization duplicates static content and introduces frame-specific errors that appear as flicker. By sharing parameters and supervision across time, DOOM-GS uses 120× fewer Gaussians and provides substantially greater temporal consistency, particularly on the larger Block scene. Although CLM-GS achieves slightly higher PSNR on Corner, DOOM-GS retains better structural, perceptual, and temporal consistency.

VariantPSNR↑SSIM↑LPIPS↓Hit↑Time↓
Corner
DOOM-GS24.930.8240.29379%15.9
w/o space-time repacking25.210.8290.29048%107.0
w/o camera scheduling23.980.7740.34452%123.2
w/o locality relocation24.830.8260.28955%88.6
Block
DOOM-GS23.190.7210.44789%37.2
w/o space-time repacking23.170.7200.44851%62.9
w/o camera scheduling22.820.6880.46755%76.7
w/o locality relocation23.230.7220.44761%53.8

Table 4. Ablation of DOOM-GS at 20M Gaussians. GPU hit denotes the fraction of block accesses. Time is training hours.

Ablation Study

We conduct an ablation study by training 20M-Gaussian models on Corner and Block with all other settings fixed. The variants disable space-time repacking, replace overlap-aware scheduling with random batches, and remove the locality constraint from relocation. We report reconstruction quality, GPU hit rate, and training time.

Space-time repacking and locality-constrained relocation improve efficiency while preserving reconstruction quality. Removing them changes PSNR by at most 0.28 and 0.10 dB, respectively, but lowers GPU hit rate by 31–38 and 24–28 percentage points and increases training time by 1.7–6.7× and 1.4–5.6×. Replacing the proposed schedule with random batches reduces PSNR by 0.95 dB on Corner and 0.37 dB on Block, lowers GPU hit rate by 27–34 percentage points, and increases training time by 2.1–7.7×. These results show that repacking and local relocation preserve block locality, while camera scheduling additionally improves optimization.

Conclusion

We introduced DOOM-GS, the first out-of-core framework for large-scale dynamic Gaussian scenes. Our space-time-aware block organization, overlap-aware camera scheduling, and streaming point splatting with gradient estimators enable training under bounded GPU memory. Experiments on our new dataset DynamicMatrixCity demonstrate improved reconstruction quality, temporal consistency, and training efficiency over dynamic and per-frame baselines.

DOOM-GS requires an explicit motion representation and the full model to remain on SSD, limiting support for implicit deformation models and increasing storage demands at extreme scales. A direct future direction is to use DOOM-GS as an efficient, explicit, and persistent memory representation for world models [2, 4, 19], potentially enabling training on moderate hardware.

References

  1. [1]Michael Broxton, John Flynn, Ryan Overbeck, Daniel Erickson, Peter Hedman, Matthew DuVall, Jason Dourgarian, Jay Busch, Matt Whalen, and Paul Devevec. Immersive light field video with a layered mesh representation. ACM Transactions on Graphics (Proc. SIGGRAPH), 39(4):86:1–86:15, 2020. 2DOI
  2. [2]Jake Bruce, Michael D Dennis, Ashley Edwards, Jack Parker-Holder, Yuge Shi, Edward Hughes, Matthew Lai, Aditi Mavalan­kar, Richie Steigerwald, Chris Apps, et al. Genie: Generative interactive environments. In Forty-first international conference on machine learning, 2024. 8arxiv.org/abs/2402.15391
  3. [3]Zhigang Cheng, Mingchao Sun, Liu Yu, Luyang Tang, Mu Xu, Yangyan Li, Peng Pan, et al. Clod-gs: Continuous level-of-detail via 3d gaussian splatting. In International Conference on Learning Representations, pages 89275–89299, 2026. 2arxiv.org/abs/2510.09997
  4. [4]Tianchen Deng, Xuefeng Chen, Yi Chen, Qu Chen, Yuyao Xu, Lijin Yang, Le Xu, Yu Zhang, Bo Zhang, Wuxiong Huang, et al. Gaussiandwm: 3d gaussian driving world model for unified scene understanding and multi-modal generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10656–10667, 2026. 8
  5. [5]Stavros Diolatzis, Tobias Zirr, Alexander Kuznetsov, Georgios Kopanas, and Anton Kaplanyan. N-dimensional gaussians for fitting of high dimensional functions. In ACM SIGGRAPH 2024 Conference Papers, pages 1–11, 2024. 1DOI
  6. [6]Yuanxing Duan, Fangyin Wei, Qiyu Dai, Yuhang He, Wenzheng Chen, and Baoyuan Chen. 4d-rotor gaussian splatting: towards efficient novel view synthesis for dynamic scenes. In ACM SIGGRAPH 2024 conference papers, pages 1–11, 2024. 2
  7. [7]Alex Hanson, Allen Tu, Vasu Singla, Mayuka Jayawardhana, Matthias Zwicker, and Tom Goldstein. Pup 3d-gs: Principled uncertainty pruning for 3d gaussian splatting. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 5494–5958. IEEE, 2025. 1
  8. [8]Guangqi Jiang, Haoran Chang, Ri-Zhao Qiu, Yutong Liang, Mazeyu Ji, Jiyue Zhu, Zhao Dong, Xueyuan Zhou, and Xiaolong Wang. Gsworld: Closed-loop photorealistic simulation suite for robot manipulation. In 2026 IEEE International Conference on Robotics and Automation (ICRA), pages 384–391. IEEE, 2026. 1
  9. [9]Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, George Drettakis, et al. 3d gaussian splatting for real-time radiance field rendering. ACM Trans. Graph., 42(4):139–1, 2023. 1arxiv.org/abs/2308.04079
  10. [10]Shakiba Kheradmand, Daniel Rebain, Gopal Sharma, Weiwei Sun, Yang-Che Tseng, Hossam Isack, Abhishek Kar, Andrea Tagliasacchi, and Kwang Moo Yi. 3d gaussian splatting as markov chain monte carlo. Advances in Neural Information Processing Systems, 37:80965–80986, 2024. 1, 4DOI
  11. [11]Shakiba Kheradmand, Delio Vicini, George Kopanas, Dmitry Lagun, Kwang Moo Yi, Mark Matthews, and Andrea Tagliasacchi. Stochasticsplats: Stochastic rasterization for sorting-free 3d gaussian splatting. In 2025 IEEE/CVF International Conference on Computer Vision (ICCV), pages 26326–26335. IEEE, 2025. 2
  12. [12]Mijeong Kim, Jongwoo Lim, and Bohyung Han. 4d gaussian splatting in the wild with uncertainty-aware regularization. Advances in Neural Information Processing Systems, 37:129209–129226, 2024. 1DOI
  13. [13]Constantin Kleinbeck, Hannah Schieber, Klaus Engel, Ralf Gutjahr, and Daniel Roth. Multi-layer gaussian splatting for immersive anatomy visualization. IEEE Transactions on Visualization and Computer Graphics, 31(5):2353–2363, 2025. 1
  14. [14]Hanyang Kong, Xingyi Yang, and Xinchao Wang. Generative sparse-view gaussian splatting. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 26745–26755. IEEE, 2025. 1DOI
  15. [15]Tianye Li, Mira Slavcheva, Michael Zollhoefer, Simon Green, Christoph Lassner, Changgil Kim, Tanner Schmidt, Steven Lovegrove, Michael Goesele, Richard Newcombe, et al. Neural 3d video synthesis from multi-view video. In 2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 5511–5521. IEEE, 2022. 2
  16. [16]Yixuan Li, Lihan Jiang, Linning Xu, Yuanbo Xiangli, Zhenzhi Wang, Dahua Lin, and Bo Dai. Matrixcity: A large-scale city dataset for city-scale neural rendering and beyond. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 3205–3215, 2023. 2, 6
  17. [17]Zhan Li, Zhang Chen, Zhong Li, and Yi Xu. Spacetime gaussian feature splatting for real-time dynamic view synthesis. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 8508–8520. IEEE, 2024. 2
  18. [18]Rong Liu, Dylan Sun, Meida Chen, Yue Wang, and Andrew Feng. Deformable beta splatting. In Proceedings of the special interest group on computer graphics and interactive techniques conference conference papers, pages 1–11, 2025. 1arxiv.org/abs/2501.18630
  19. [19]Guanxing Lu, Baoxiong Jia, Puhao Li, Yixin Chen, Ziwei Wang, Yansong Tang, and Siyuan Huang. Gwm: Towards scalable gaussian world models for robotic manipulation. Proceedings of International Conference on Computer Vision (ICCV), 2025. 8
  20. [20]Albert Pumarola, Enric Corona, Gerard Pons-Moll, and Francesc Moreno-Noguer. D-NeRF: Neural Radiance Fields for Dynamic Scenes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020. 2arxiv.org/abs/2011.13961
  21. [21]Joris Rijsdijk, Christoph Peters, Michael Weinmann, and Ricardo Marroquim. Gaussian point splatting. ACM Trans. Graph., 45(4), 2026. 1, 2, 5DOI
  22. [22]Samuel Rota Bulò, Lorenzo Porzi, and Peter Kontschieder. Revising densification in gaussian splatting. In European Conference on Computer Vision, pages 347–362. Springer, 2024. 1arxiv.org/abs/2404.06109
  23. [23]Vikram Sandu, Mayurdeep Pathak, and Rajiv Soundararajan. Temporally aware densification for dynamic 3d gaussian splatting. In European Conference on Computer Vision, pages 58–75. Springer, 2026. 1
  24. [24]Jianxiang Shen, Yue Qian, and Xiaohang Zhan. Lod-gs: Achieving levels of detail using scalable gaussian soup. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 671–680. IEEE, 2025. 2
  25. [25]Tianchang Shen, Shervin Bahmani, Kai He, Sangeetha Grama Srinivasan, Tianshi Cao, Jiawei Ren, Ruilong Li, Zian Wang, Nicholas Sharp, Zan Gojcic, et al. Lyra 2.0: Explorable generative 3d worlds. arXiv preprint arXiv:2604.13036, 2026. 1
  26. [26]Mingyang Song, Yang Zhang, Marko Mihajlovic, Siyu Tang, Markus Gross, and Tunç Ozan Aydin. Spline deformation field. In Proceedings of the Special Interest Group on Computer Graphics and Interactive Techniques Conference Conference Papers, pages 1–10, 2025. 1, 2DOI
  27. [27]Chengkai Wang, Luoyu Hong, Yiting Zhao, Jiamin Wang, Xiang Feng, Feiwei Qin, Zhenzhong Kuang, Xuefei Yin, Ali Bashashati, and Yanming Zhu. Medgssr: Generalizable medical image super-resolution 3d reconstruction via hierarchical feed-forward gaussian splatting. In European Conference on Computer Vision, 2026. 1arxiv.org/abs/2609.06874
  28. [28]Daniel Wang, Patrick Rim, Tian Tian, Dong Lao, Alex Wong, and Ganesh Sundaramoorthi. Ode-gs: Latent odes for dynamic scene extrapolation with 3d gaussian splatting. In International Conference on Learning Representations, pages 131975–131997, 2026. 2arxiv.org/abs/2506.05480
  29. [29]Yifan Wang, Peishan Yang, Zhen Xu, Jiaming Sun, Zhanhua Zhang, Yong Chen, Hujun Bao, Sida Peng, and Xiaowei Zhou. Freetimags: Free gaussian primitives at anytime anywhere for dynamic scene reconstruction. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 21750–21760. IEEE, 2025. 1, 2
  30. [30]Felix Windisch, Thomas Köhler, Lukas Radl, Mattia D’Urso, Michael Steiner, Dieter Schmalstieg, and Markus Steinberger. A LoD of Gaussians: Unified Training and Rendering for Ultra-Large-Scale Reconstruction with External Memory. In Proceedings of ACM SIGGRAPH 2026, New York, NY, USA, 2026. ACM. 1, 2, 4, 6, 8DOI
  31. [31]Guanjun Wu, Taoran Yi, Jiemin Fang, Lingxi Xie, Xiaopeng Zhang, Wei Wei, Wenyu Liu, Qi Tian, and Xinggang Wang. 4d gaussian splatting for real-time dynamic scene rendering. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 20310–20320. IEEE, 2024. 2arxiv.org/abs/2310.08528
  32. [32]Yuxuan Wu, Lei Pan, Wenhua Wu, Guangming Wang, Yanzi Miao, Fan Xu, and Hesheng Wang. Rl-gsbridge: 3d gaussian splatting based real2sim2real method for robotic manipulation learning. In 2025 IEEE International Conference on Robotics and Automation (ICRA), pages 192–198. IEEE, 2025. 1arxiv.org/abs/2409.20291
  33. [33]Ziyi Yang, Xinyu Gao, Wen Zhou, Shaohui Jiao, Yuqing Zhang, and Xiaogang Jin. Deformable 3d gaussians for high-fidelity monocular dynamic scene reconstruction. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 20331–20341. IEEE, 2024. 2arxiv.org/abs/2309.13101
  34. [34]Zeyu Yang, Hongye Yang, Zijie Pan, and Li Zhang. Real-time photorealistic dynamic scene representation and rendering with 4d gaussian splatting. In International Conference on Learning Representations (ICLR), 2024. 1arxiv.org/abs/2310.10642
  35. [35]Zeyu Yang, Hongye Yang, Zijie Pan, and Li Zhang. Real-time photorealistic dynamic scene representation and rendering with 4d gaussian splatting. In International Conference on Learning Representations, pages 9142–9159, 2024. 2arxiv.org/abs/2310.10642
  36. [36]Weihao Yu, Yuanhao Cai, Ruyi Zha, Zhiwen Fan, Chenxin Li, and Yixuan Yuan. 4d radiative gaussian splatting for continuous-time tomographic reconstruction. In 2025 IEEE/CVF International Conference on Computer Vision (ICCV), pages 24728–24738. IEEE, 2025. 1
  37. [37]Doğa Yılmaz, Jialin Zhu, Deshan Gong, and He Wang. Graphical x splatting (graphix): A graphical model for 4d gaussian splatting under uncertainty. In SIGGRAPH Conference Papers ’26, New York, NY, USA, 2026. ACM. 1, 2, 6DOI
  38. [38]Hexu Zhao, Xiwen Min, Xiaoteng Liu, Moonjun Gong, Yiming Li, Ang Li, Saining Xie, Jinyang Li, and Aurojit Panda. Clm: Removing the gpu memory barrier for 3d gaussian splatting. In Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, pages 377–393, 2026. 1, 2, 4, 5, 6, 8arxiv.org/abs/2511.04951
  39. [39]Chonghao Zhong, Linfeng Shi, Hua Chen, Tiecheng Sun, Hao Zhao, Binhang Yuan, and Chaojian Li. TideGS: Scalable training of over one billion 3d gaussian splatting primitives via out-of-core optimization. In International Conference on Machine Learning. PMLR, 2026. 1, 2, 3, 5, 6, 8arxiv.org/abs/2605.20150
  40. [40]Jialin Zhu, Jiangbei Yue, Feixiang He, and He Wang. 3d student splatting and scooping. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 21045–21054. IEEE, 2025. 1arxiv.org/abs/2503.10148

Paper details

vlnc:W_zx59crth
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents