Preprint
Review

This version is not peer-reviewed.

A Comprehensive Survey of 4D Gaussian Splatting for Dynamic Scene Reconstruction

  † These authors contributed equally to this work.

Submitted:

30 October 2026

Posted:

03 November 2026

You are already at the latest version

Abstract
4D Gaussian splatting (4DGS) has rapidly become a prominent approach to dynamic scene reconstruction and free-viewpoint rendering, inheriting the explicit primitives and real-time rasterization of 3D Gaussian splatting while adding a temporal axis. Although 4DGS is a nascent area of research, the number of methods has grown explosively, making it difficult to navigate. In this paper, we survey recent progress in 4DGS. Specifically, we cover three major themes: (i) representations, organized into deformation-based, native 4D-primitive, hybrid/decomposition, anchor/stream- ing, and feed-forward/generalizable families; (ii) compression and storage efficiency, the defining practical bottleneck of 4DGS; (iii) applications, including autonomous driving, 4D content generation, editing and semantics, event and constrained capture, and avatars/robotics/medicine. We also present comparative results on widely used benchmarks, together with observations and future research directions. A taxonomy and chronological overview of representative methods are provided throughout this survey to help readers situate individual works.
Keywords: 
;  ;  ;  ;  ;  ;  

1. Introduction

With the swift development of 3D acquisition and the breakthrough of 3D Gaussian splatting (3DGS) [1], modeling and rendering dynamic scenes has become a central problem in computer vision and graphics, with applications in augmented and virtual reality, autonomous driving, robotics, telepresence, and content creation. 3DGS represents a static scene as a set of explicit anisotropic Gaussians and renders by differentiable rasterization, achieving photorealistic quality at real-time speed. Its significance is less about the quality itself, which neural radiance fields (NeRFs) have already attained, than how that quality is paid for. 3DGS replaces the slow per-ray volumetric integration of NeRF with a fast, sort-and-blend rasterizer over an explicit primitive set. This single design choice makes the 4D extension attractive. An explicit primitive can be moved, deformed, born, or pruned individually, while the real-time rasterizer is inherited unchanged.
Extending this explicit, real-time paradigm to the temporal domain, 4D Gaussian splatting (4DGS), is natural but non-trivial. The difficulty is best understood as a set of tensions rather than a single missing component. First, time must be encoded somewhere. For example, in a deformation field that warps a shared canonical set, in the primitives themselves (a 4D mean and covariance), or in a decomposition that treats static and dynamic content differently. This choice trades compactness against expressiveness. Second, motion is not smooth. Real scenes contain fast, abrupt, and topology-changing events (content that appears and vanishes), which a low-rank or single-canonical model blurs. Third, and most consequentially for deployment, the explicitness that buys speed also imposes a severe storage burden. A few seconds of multi-view video can require gigabytes of Gaussians, thus 4DGS uniquely couples a reconstruction problem to a compression problem. Fourth, capture is often monocular or otherwise constrained, in which geometry and motion are entangled and the problem is fundamentally underdetermined. Finally, the field-wide default of per-scene optimization caps practicality, motivating feed-forward models that amortize reconstruction over a training corpus. These tensions (i.e., representation, motion complexity, storage, capture, and inference regime) recur throughout this survey and motivate its organization.
Deep learning on 4DGS has attracted increasing attention, especially in the last two years, with numerous methods proposed to address different facets of these tensions. A number of public benchmarks underpin this progress, including the Neural 3D Video / Plenoptic dataset [2], Technicolor, the synthetic monocular D-NeRF benchmark, HyperNeRF and NeRF-DS for real monocular capture, and the driving datasets KITTI, Waymo Open, and nuScenes. These datasets have boosted research on high-fidelity novel view synthesis of dynamic scenes, compact and streamable representations, feed-forward (generalizable) reconstruction, and downstream tasks such as driving simulation, 4D generation, and editing. A few related surveys exist on dynamic 3DGS for robotics [3], on real-time rendering and streaming [4], and on Gaussian compression [5,6]. These existing surveys are valuable, but each one only deals with a slice of the problem. Differently, this survey jointly organizes 4DGS approaches across representations, compression, and applications within a single taxonomy, and most crucially, separates how time is modeled from the orthogonal axes of efficiency and inference. As a result, methods that are often conflated (e.g., an anchor-based efficiency wrapper around a deformation representation) can be placed precisely.
Compared to the existing literature, the major contributions of this survey paper are summarized as follows.
1.
We organize 4DGS within a single framework spanning three themes: representations (five distinct families of methods), compression and storage efficiency, and applications.
2.
As opposed to surveys that treat dynamic 3DGS as one block, we provide a fine-grained taxonomy that separates how time is modeled (deformation, native 4D, hybrid) from the orthogonal axes of efficiency (anchor/streaming, compression) and inference (per-scene optimization vs. feed-forward). We make the shared notation explicit so that the families can be compared on equal terms.
3.
This survey covers the latest progress, including 2025–2026 venues (e.g., CVPR/ICRA/NeurIPS) and recent journal articles, providing readers with a current snapshot of the field.
4.
Structured comparisons of representative techniques on common benchmarks are provided (e.g., Tables 4 and 5), together with a critique of each spotlight method and a detailed, evidence-based discussion of open challenges and future directions.
Rather than a strict partition, this paper is organized as a multi-axis design space. An individual method is a choice of coordinates along several largely independent axes, and most works combine choices rather than occupy a single bin. The principal axes are (i) time representation—how the temporal dimension enters the model (e.g., a deformation field over a shared canonical set, native 4D primitives, or a static/dynamic decomposition); (ii) efficiency mechanism—an optional anchor/scaffold, streaming, or compression layer wrapped around that representation; (iii) inference regime—per-scene optimization versus a feed-forward, generalizable predictor; and (iv) capture modality and supervision—dense multi-view rigs, monocular video, or event and other constrained sensors. Reading the field this way is what lets approaches that are routinely conflated be cleanly separated. An anchor-based efficiency wrapper (axis ii) around a deformation representation (axis i) is a different object from a native-4D representation, even though both are often labeled “4DGS.” We use these axes throughout to situate each method, and the family-based taxonomy (Figure 1) is the primary, time-representation axis of this space. This multi-axis view is not merely an organizational preference, it resolves a specific classification failure in how the field is currently discussed. Single-axis taxonomies, whether organized around a single representation type, a single efficiency mechanism, or a single application, force methods that combine choices along independent axes into an awkward either/or bin, obscuring which design decision is actually responsible for a method’s reported gains.

1.1. Scope and Methodology

We focus on 4DGS for dynamic-scene reconstruction, free-viewpoint rendering, and the downstream tasks built on them. Static-3DGS techniques appear only as foundations (e.g., for compression), and dynamic-NeRF methods are included only as baselines.
Search strategy. The works surveyed were identified through a combination of manual screening of proceedings from major computer vision, computer graphics, and robotics venues (e.g., CVPR, ICCV, ECCV, NeurIPS, ICLR, SIGGRAPH, SIGGRAPH Asia, ICRA), and keyword-based search of arXiv listings (e.g., "4D Gaussian splatting," "dynamic Gaussian splatting," "spacetime Gaussian," "deformable Gaussian splatting," and "Gaussian splatting compression"), spanning 2023 through early 2026. This dual approach lets the survey capture both peer-reviewed venue publications and the fast-moving arXiv preprints that, in this field, often precede formal publication by many months.
Inclusion and exclusion criteria. A paper was included if it (i) proposes or substantively extends a dynamic-scene or 4D method built on explicit Gaussian primitives, or (ii) supplies a compression or architectural building block that surveyed 4DGS methods directly inherit (Section 4). Papers were excluded if they addressed purely static 3DGS with no temporal component and no such inherited role, or if they were superseded by a later, more complete version from the same authors that is cited in their place.
Selection of coverage. Given the pace of development in this area, with dozens of new methods in roughly two years, we prioritize representative and influential works and a consistent organizing framework over exhaustive enumeration, judged by a combination of venue, reported results relative to concurrent work, and the distinctness of the design choice a method contributes to our taxonomy (Section 3). Within each family, we discuss a small number of spotlight methods in depth and reference related works around them. Quantitative results are reproduced as reported by each paper under its own protocol and are therefore indicative rather than strictly comparable. Section 2 details the evaluation metrics and the resulting benchmarking caveats, and Section 6 returns to this limitation directly.
The structure of this survey paper is the following. Section 2 introduces the background, datasets, and evaluation metrics. Section 3 reviews 4DGS representations, grouped into five families, and closes with a comparative summary. Section 4 surveys compression and storage efficiency. Section 5 presents applications. Open challenges and future directions are listed in Section 6, and Section 7 concludes the paper.

1.2. Comparison to Existing Surveys

Several existing surveys touch on Gaussian splatting, To the best of our knowledge, but to the best of our knowledge, none is centered on 4D/dynamic Gaussian splatting for reconstruction with a representation-family taxonomy at the granularity we adopt here. Table 1 summarizes this landscape along three axes: whether dynamic/4D representations are differentiated into distinct families, whether compression is covered, and whether downstream applications are covered.
Among surveys with a narrower lens, Zhu et al. [7] cover static 3DGS for robotics without treating dynamic representations as a differentiated axis, while Youn et al. [8], Ali et al. [9], and Bagdasarian et al. [10] focus on compression: the first spans static and dynamic GS but organizes its taxonomy around compression mechanisms rather than reconstruction representations, while the latter two are restricted to static 3DGS. Chen and Wang [11], Fei et al. [12], and Bao et al. [13] instead survey 3DGS broadly, spanning representation, reconstruction, manipulation, generation, perception, and applications from robotics to virtual humans and endoscopy; each treats dynamic/4D content as a subsection rather than as a decomposed set of representation families. The closest prior work is Zhu and Tang [14], which differentiates dynamic 3DGS into deformation-based, per-frame, and native-4D approaches, but spans both dynamic NeRF and dynamic 3DGS, does not treat anchor/streaming or feed-forward/generalizable methods as distinct families, gives storage efficiency only limited treatment, and restricts its applications to free-viewpoint and volumetric video. Beyond Gaussian splatting specifically, Cao et al. [15] and Zhao et al. [16] survey 4D reconstruction and generation at a broader, representation-agnostic scope, organized by capability level and by geometry/motion/interaction pillars, respectively, rather than by representation type, Gaussian splatting appears in both only as one implementation choice among several (alongside NeRF and feed-forward methods).

2. Background

2.1. From 3DGS to 4DGS

3DGS [1] represents a scene by a set of Gaussians, each with mean μ ∈ R 3 , covariance Σ = R S S ⊤ R ⊤ (rotation R , scale S ), opacity α , and view-dependent color via spherical harmonics (SH). Rendering projects Gaussians to screen space and a l p h a -compositing them front-to-back, a fully differentiable process and GPU-rasterizable in real time. Extending this to a time-varying scene requires encoding, for every instant t, the geometry, appearance, and visibility of all primitives. Two broad strategies have emerged: (i) keep one canonical 3DGS and warp it with a learned deformation field  F ( · , t ) , and (ii) lift the primitive itself into 4D space-time and slice it at time t. Conditioning a 4D Gaussian on t yields an ordinary 3D Gaussian (whose center translates with a velocity v and whose opacity is scaled by a temporal marginal). Therefore, both strategies ultimately feed the unmodified 3DGS rasterizer, which is the property that makes 4DGS fast. These two strategies, together with hybrid, anchor/streaming, and feed-forward variants, define the taxonomy of Section 3. Figure 2 situates these representations within the end-to-end 4DGS pipeline, from dataset capture through initialization and the 4D representation to rendered novel views.

2.2. Datasets

A range of datasets is used to evaluate 4DGS for different capture regimes. They divide into synthetic versus real, monocular versus multi-view, and object/indoor versus outdoor/driving. Synthetic monocular sets (e.g., D-NeRF) provide a clean sanity check for deformation methods, real monocular sets (HyperNeRF, NeRF-DS) stress topology change and specularities, real multi-view sets (Neural 3D Video / Plenoptic [2], Technicolor) are the standard for high-fidelity volumetric video, and driving datasets (KITTI, Waymo Open, nuScenes) target large, mostly-rigid outdoor dynamics. Table 2 summarizes the representative datasets and their attributes.

2.3. Evaluation Metrics

For dynamic novel view synthesis, the most frequently used image-quality metrics are peak signal-to-noise ratio (PSNR), structural similarity (SSIM), and learned perceptual image patch similarity (LPIPS). Higher PSNR/SSIM and lower LPIPS scores are better. Since 4DGS is an explicit, real-time representation, three systems metrics are equally important: rendering speed (in frames per second (FPS)), training time, and model size (MB, or per-frame bitrate for streaming). Compression methods are additionally judged by rate-distortion (RD): image quality plotted against model size/bitrate, ideally as a curve rather than a single operating point. For driving and detection applications, standard task metrics (e.g., average precision) are used. Throughout this survey, we report numbers as stated by each paper under its own protocol. Due to the differences among base models, datasets, and resolutions, cross-method numbers are indicative rather than strictly comparable (Section 6 returns to this benchmarking gap).

3. 4DGS Representations

At the highest level, 4DGS approaches differ in how the time dimension enters the representation. Three families answer this directly: deformation-based, native 4D-primitive, and hybrid/decomposition. Two further families are orthogonal: anchor/scaffold and streaming techniques target efficiency while feed-forward/generalizable methods change the inference regime from per-scene optimization to a single forward pass. Figure 2 shows the larger picture of how data is recorded and processed by multiple 4D representations (Figure 3), while Figure 4 provides a chronological overview of the representative methods, color-coded by family. We first fix the notation shared by the families (Section 3.1), then treat each family in turn.

3.1. Preliminaries and Notation

Static 3DGS. A static scene is a set of N anisotropic Gaussian primitives G = { G i } i = 1 N . Each G i stores a mean (center) μ i ∈ R 3 , a covariance Σ i ∈ R 3 × 3 , an opacity o i ∈ [ 0 , 1 ] , and a view-dependent color c i encoded by SH coefficients. To keep Σ i positive semi-definite during optimization, it is factored into a rotation R i (from a unit quaternion q i ) and a per-axis scale S i = diag ( s i ) ,
Σ i = R i S i S i ⊤ R i ⊤ .
The Gaussian’s spatial response at a point x is G i ( x ) = exp − 1 2 ( x − μ i ) ⊤ Σ i − 1 ( x − μ i ) .
Rendering. For a camera with viewing transform W and projection Jacobian J , each primitive is projected to a 2D Gaussian with mean μ i 2 D and covariance Σ i 2 D = J W Σ i W ⊤ J ⊤ . A pixel color C is obtained by depth-ordered α -compositing of the primitives overlapping it,
C = ∑ i = 1 n c i α i ∏ j = 1 i − 1 ( 1 − α j ) , α i = o i G i 2 D ( p ) ,
where p is the pixel location and G i 2 D is the projected response. The parameters are fit by minimizing a photometric loss (an L 1 plus D-SSIM term) against the input views. Adaptive density control is used to clone, split, and prune the primitives during training.
From 3D to 4D. A dynamic scene adds a time coordinate t. We write the time-varying parameters of primitive i as μ i ( t ) , Σ i ( t ) , o i ( t ) , and c i ( t ) . The families differ only in how these functions of t are realized. Concretely, a deformation field warps a shared canonical set (Section 3.2), native approaches give each primitive an intrinsic 4D extent and obtain the 3D parameters by time-slicing (Section 3.3), hybrid techniques split the scene into static ( ∂ t = 0 ) and dynamic subsets (Section 3.4), and anchor methods predict the parameters from a sparse set of anchors in one pass (Section 3.6).

3.2. Deformation-Based Methods

Deformation-based approaches maintain one canonical Gaussian set G c defined at a reference time and learn a time-conditioned deformation field F θ that warps it to each instant. Formally, for a canonical primitive with centre μ i c , rotation q i c , and scale s i c , the field predicts residuals
F θ ( μ i c , t ) = ( Δ μ i , Δ q i , Δ s i ) .
The deformed primitive at time t is μ i ( t ) = μ i c + Δ μ i , q i ( t ) = q i c ⊕ Δ q i , s i ( t ) = s i c + Δ s i , where ⊕ is a quaternion update. Σ i ( t ) then follows from (1) and rendering from (2).
The design choices are what parameterizes F θ and what conditions it. Deformable 3D Gaussians [18] make F θ a single-coordinate multilayer perceptron (MLP) on positionally encoded ( μ i c , t ) , adding annealed smoothing (decaying noise injected into the time input) to tolerate pose noise and overfitting; they target monocular reconstruction. GaGS [19] voxelizes G c and extracts sparse-convolution features, so F θ is informed by local 3D geometry. Very recent monocular work replaces the opaque MLP with an explicit, editable S E ( 3 ) B-spline motion basis { T k ( t ) } ⊂ S E ( 3 ) over a compact set of control points, writing μ i ( t ) = ∑ k w i k T k ( t ) μ i c and adaptively growing the bases with multi-view diffusion cues [20].

Spotlight

4DGaussians [21] popularized the “4DGS” name. As shown in Figure 5, the framework keeps a single canonical set G c and a Gaussian deformation field F = { H , D } . The encoder H is a HexPlane-style decomposed 4D feature volume. Rather than a dense O ( R 4 ) voxel grid over ( x , y , z , t ) , it stores six multi-resolution feature planes: three spatial { x y , x z , y z } and three spatio-temporal { x t , y t , z t } . Thus, the storage and lookup cost is O ( R 2 ) instead of O ( R 4 ) . The feature for a canonical center μ i c = ( x , y , z ) at time t is the element-wise product of the six bilinearly interpolated plane features,
f i ( t ) = ∏ ( a , b ) ∈ { x y , x z , y z , x t , y t , z t } interp P a b , π a b ( μ i c , t ) ,
where π a b projects onto plane P a b . A tiny multi-head decoder D maps f i ( t ) to the deformations ( Δ μ i , Δ q i , Δ s i ) of (3). Training is coarse-to-fine. A static canonical 3DGS is warmed up, then { H , D } and G c are optimized jointly. Since the output is an ordinary 3D Gaussian set, the unmodified rasterizer reaches ≈82 FPS at 800 2 on synthetic scenes (NVIDIA GeForce RTX 3090), dropping to ≈30 FPS on Neural 3D Video (N3DV) at full resolution (Table 4). Critique: the low-rank plane factorization that buys the O ( R 2 ) cost also oversimplifies rapid or aperiodic motion (e.g., blur in fast regions), the single-canonical assumption cannot create/destroy content gracefully, and per-Gaussian feature lookups cap speed relative to native slicing.

3.3. Native 4D-Primitive Approaches

These methods lift the primitive itself to 4D and render by temporal slicing. A native primitive has a 4D mean μ i 4 D = ( μ x y z , μ t ) ∈ R 4 and a 4 × 4 covariance, written in block form as
Σ 4 D = Σ x y z Σ x t Σ x t ⊤ σ t t .
Conditioning on a query time t (slicing) yields a 3D Gaussian whose mean and covariance are the Gaussian conditionals (Schur complement),
μ x y z ( t ) = μ x y z + Σ x t σ t t − 1 ( t − μ t ) , Σ 3 D ( t ) = Σ x y z − Σ x t σ t t − 1 Σ x t ⊤ ,
and a time-marginal scales the opacity, o i ( t ) = o i exp − ( t − μ t ) 2 2 σ t t . Therefore, a primitive is “born” and “dies” around μ t , which is how native methods model transient content. The slice (6) is then rendered by the standard pipeline (2). RealTime4DGS [22] realizes exactly this with 4D SH appearance. In particular, an extended journal version reformulates dynamic scenes as native 4D-volume learning and derives memory-reduced variants [23]. 4D-Rotor GS [24] parameterizes the 4D rotation by a rotor  R = exp ( 1 2 ∑ a < b θ a b e a e b ) from geometric algebra (the six bivector angles θ a b span the SO ( 4 ) rotation), adds entropy and 4D-consistency losses, and reaches 277 / 583 FPS on an NVIDIA GeForce RTX 3090/4090 with a custom CUDA slicer. Disentangled4DGS [25] avoids forming Σ 4 D or the slice (6) at all. Instead, it disentangles temporal and spatial deformation into ray space, rendering 1352 × 1014 at 343 FPS.
Whereas these methods assume dense multi-view rigs, 4C4D [26] (CVPR’26) pushes native 4DGS into the extremely sparse regime by using as few as four portable cameras. Its key observation is that, under sparse views, geometry is far harder to learn than appearance, thus vanilla 4DGS over-fits appearance and produces floaters. As depicted in Figure 6, 4C4D predicts a per-Gaussian opacity-decay factor from each primitive’s attributes, steering gradients toward geometric learning and rebalancing the ill-posed geometry-versus-appearance optimization. It is jointly trained with the 4D Gaussians using a photometric loss and achieves strong sparse-view dynamic novel view synthesis (NVS) results, signaling a broader shift from rig-bound capture toward consumer-level 4D.

Spotlight

Whereas the previously discussed native designs assume a dense multi-view rig, 4C4D targets the extremely sparse regime, as few as four portable cameras, where the photometric loss alone severely under-constrains the scene. Its premise is an explicit imbalance. With so few views, geometry (the means μ i and covariances Σ i ) is far less constrained than appearance (opacity o i and color c i ). Hence, a vanilla 4D field can drive the rendering loss down by over-fitting per-view appearance, inflating opacities, and spawning floaters and spurious transient primitives, rather than by recovering correct geometry. 4C4D counters this with two ingredients. The first is dense geometric initialization. Since COLMAP returns only a handful of points under four-camera capture, the Gaussians are initialized from a dense cloud produced by a learned multi-view-stereo matcher (MASt3R). This supplies a geometric prior before any photometric fitting. The second is a neural decaying function. This lightweight network f θ maps a primitive’s key attributes a i (e.g., scale, opacity, and temporal extent) to a per-Gaussian decay factor that attenuates the opacity entering rasterization,
γ i = f θ ( a i ) ∈ ( 0 , 1 ] , o ^ i ( t ) = γ i o i ( t ) ,
where o i ( t ) is the native time-marginal opacity. Rendering with the decayed weights w ^ i = o ^ i ∏ j < i ( 1 − o ^ j ) in the front-to-back composite (2), the gradient that the photometric loss L delivers to a primitive’s appearance parameters is proportional to that primitive’s blended contribution,
∂ L ∂ c i ∝ w ^ i = γ i o i ( t ) ∏ j < i ( 1 − o ^ j ) .
Therefore, driving γ i → 0 on weakly-supported Gaussians suppresses their appearance updates and lets the relative gradient flow to the geometry terms μ i , Σ i . Because f θ conditions on each primitive’s own state, the model learns where to discount appearance-driven explanations rather than imposing a global opacity schedule. The decay network and the 4D Gaussians are optimized jointly under the standard photometric objective L = ( 1 − λ ) L 1 + λ L D - SSIM , with gradients propagating through (7) into θ . Across sparse-view benchmarks with varying camera overlap, N3DV and a self-captured four-camera Dyn4Cam set, 4C4D reports superior dynamic NVS over prior sparse-view techniques. Critique: the rebalancing is a learned prior, not a guarantee. Its benefit outside the four-camera MASt3R-initialized setting is uncharacterized, and sparse-view quality still trails dense-rig baselines, thus 4C4D narrows that gap rather than closing it.

3.4. Hybrid and Static-Dynamic Decomposition

Most real scenes are mainly static with localized motion, which makes modeling everything dynamically wasteful. Decomposition methods split the primitive set into a time-invariant static part and a dynamic part, G = G s ∪ G d with ∂ t G s = 0 , and spend the expensive temporal modeling only on G d . The assignment is driven by a per-primitive dynamic indicator β i ∈ [ 0 , 1 ] obtained from masks, from 3D boxes (common in driving), or learned self-supervised. In particular, S3Gaussian [27] decomposes static/dynamic content self-supervised, without boxes; DeSiRe-GS [28] recovers dynamic street scenes via a two-stage self-supervised pipeline that first extracts 2D motion masks and then lifts them into dynamic Gaussians; SDD-4DGS [29] makes β i a probabilistic dynamic-perception coefficient for adaptive separation; and Hybrid 3D–4DGS [30] begins fully 4D and iteratively converts temporally invariant primitives ( s i τ → 0 , i.e., near-constant over t) back to 3D, cutting redundancy.

Spotlight

Figure 7 illustrates the object-centric static-dynamic decomposition used by Street Gaussians [31], a canonical decomposition method for urban scenes. It factors the world into a static background set G s in world coordinates, plus a set of K foreground object models { G k o } , each a 3DGS in its own object-centric frame paired with an optimized tracked 6-DoF pose T k ( t ) = [ R k ( t ) | t k ( t ) ] ∈ S E ( 3 ) . At time t, each object’s primitives are rigidly mapped into the world μ k , i world ( t ) = R k ( t ) μ k , i + t k ( t ) and Σ k , i world ( t ) = R k ( t ) Σ k , i R k ( t ) ⊤ , and the scene is rendered as G s ∪ ⋃ k T k ( t ) G k o via (2). A time-dependent (4D-SH-style) appearance model per object absorbs lighting changes. Static pixels, which compose most of a street scene, are modeled once and cheaply. The dynamics collapse to compact, interpretable rigid pose sequences T k ( t ) , and the explicit instance decomposition makes the scene editable (insert, remove, reposition vehicles), exactly what closed-loop driving simulation needs. Critique: The approach depends on external tracking/boxes and assumes rigid objects ( μ k , i constant in the object frame), so non-rigid actors (e.g., pedestrians) are handled worse than cars.

3.5. Anchor/Scaffold and Streaming Methods

This family of techniques targets storage, training time, long-video scalability, and composes with the others. Instead of storing every primitive, a sparse set of anchors  { a m } on a voxel grid each carry a context feature h m . The attributes of the k neural Gaussians they spawn are predicted on the fly by small MLPs,
{ ( μ m j , q m j , s m j , o m j , c m j ) } j = 1 k = MLP ϕ h m , a m , d view ,
thus only { a m , h m } and ϕ are stored. Scaffold-GS [32] is the static foundation of this idea. 4D Scaffold GS [33] lifts it to 4D with dynamic-aware anchor growing that allocates anchors to under-reconstructed moving regions. Anchored 4DGS [34] conditions the anchors on time and slices neural Gaussians per timestep and SD-GS [35] uses a deformable anchor grid with deformation-aware densification. These methods achieve large storage reductions (Section 4).

Spotlight

As illustrated in Figure 8, 3DGStream [36] is an online method that reconstructs free-viewpoint video on the fly. After fitting a static 3DGS at t = 0 , each frame is handled in two stages. Stage 1 trains a neural transformation cache (a compact multi-resolution hash grid and shallow MLP) that maps each Gaussian’s position to a translation and rotation by warping frame i − 1 to i. Stage 2 adaptively spawns a few frame-specific Gaussians to explain emerging content. Encoding per-frame change as a compact field of rigid corrections keeps per-frame deltas to tens of MB and training to ≈12 s while preserving real-time rendering. This makes the framework one of the first practical streamable free-viewpoint video pipelines. Critique: errors accumulate over long sequences and the background can flicker since every frame is bootstrapped from its predecessor.

3.6. Feed-Forward and Generalizable Methods

All of the families previously mentioned optimize one model per scene, costing minutes to hours. A distinct, rapidly emerging paradigm trains a network  Φ θ that maps an input video (and poses) directly to a 4D representation in a single forward pass,
Φ θ { I t } t = 1 T , { P t } ⟼ G ( t ) ,
amortizing reconstruction over a training corpus such that a new scene needs only inference (no per-scene optimization). Application-specific systems include the following: D-FCGS [37] compresses inter-frame motion in one feed-forward pass; DrivingScene [38] reconstructs dynamic driving scenes online from two surround-view frames; and ADGaussian [39] predicts generalizable street Gaussians from a single multi-modal (image plus sparse-LiDAR) view.

Spotlight

As shown in Figure 9, 4DGT [40] is a prominent generalizable model based on a 4D Gaussian transformer trained end-to-end on large collections of real-world monocular posed videos. It uses a 4D Gaussian as an inductive bias that unifies static and dynamic content into a single primitive type with varying temporal lifespans. Thus, the network need not classify motion separately. It ingests 64 consecutive posed frames in a rolling window and predicts consistent 4D Gaussians with a learned density-control strategy for long inputs. Being purely feed-forward, the model collapses reconstruction from hours to seconds and scales to long sequences, significantly outperforming prior feed-forward Gaussian networks on real video and reaching parity with per-scene optimizers cross-domain. Critique: in-domain accuracy still trails the best optimizers, and quality depends on training-corpus diversity and on accurate input poses.

3.7. Summary

Table 3 contrasts the five families of 4DGS approaches and Table 4 lists representative quantitative results. From these tables the following observations can be drawn.
  • Deformation methods are the most compact and train the fastest, but incur blur fast/abrupt motion and struggle with topology change. They predominate in monocular reconstruction.
  • Native 4D techniques provide the best quality and the fastest rendering. They natively handle emerging/vanishing content, at the cost of storage, the bottleneck that motivates Section 4.
  • Hybrid decomposition is a natural fit for driving and other mostly-static scenes and uniquely enables instance-level editing, but needs a separation mechanism.
  • Anchor/streaming approaches are orthogonal efficiency wrappers that compose with the other families and are essential for long-video and on-the-fly capture.
  • Feed-forward methods are the most likely route past the per-scene-optimization bottleneck. They are the newest family and currently trade some in-domain accuracy for orders-of-magnitude faster inference.
Table 4. Representative dynamic-NVS results on the N3DV dataset at 1352 × 1014 . PSNR is the six-scene mean while the values are as reported by each paper. Scene subsets, training schedules, and GPUs differ, thus cross-method figures are indicative. Uncompressed native models are large (hundreds of MB-GB; cf. §Section 4). FPS GPUs: aRTX 3090, bRTX 4090.
Table 4. Representative dynamic-NVS results on the N3DV dataset at 1352 × 1014 . PSNR is the six-scene mean while the values are as reported by each paper. Scene subsets, training schedules, and GPUs differ, thus cross-method figures are indicative. Uncompressed native models are large (hundreds of MB-GB; cf. §Section 4). FPS GPUs: aRTX 3090, bRTX 4090.
Method Family PSNR ↑ FPS ↑ Size ↓
4DGaussians [21] Deform. 31.15 ≈30 atens of MB
RealTime4DGS [22] Native 31.96 114a ≈2 GB
Spacetime Gaussian [41] Native 32.05 140a ≈200 MB/300f
4D-Rotor GS [24] Native 31.62 277a/583b large (uncompr.)
Disentangled4DGS [25] Native 32.75 343a ≈4.5% < 4D-Rotor
3DGStream [36] Anchor/str. 31.67 ≈200a 7.8 MB/frame

4. Compression and Storage Efficiency

Storage is the defining practical bottleneck of 4DGS. Native representations are especially costly. For instance, a faithful 10-second multi-view clip can exceed 6 GB [33], and an unconstrained RealTime4DGS model can occupy ≈2 GB [42]. This has spawned a fast-growing sub-field, organized by two dedicated surveys [5,6].

4.1. Taxonomy of Compression Techniques

Following the recent literature [5], compression splits into parameter compression (shrink what each primitive stores) and restructuring compression (change how primitives are organized and predicted). Seven techniques recur, and are often combined (Figure 10): (1) primitive-count reduction (pruning/merging, targeting short-lifespan/inactive primitives in 4D); (2) attribute compaction (low-dimensional features and tiny decoder instead of bulky SH); (3) quantization and codebooks (scalar/vector/residual vector quantization (VQ), extended to 4D); (4) entropy coding with context models (arithmetic coding driven by a learned hash or implicit neural representation (INR) hyperpriors); (5) structured / anchor prediction (predict many Gaussians from sparse anchors); (6) temporal-redundancy modeling (inter-frame residuals, Group-of-Pictures I-P coding, motion grids, active masks); and (7) rate-aware and feed-forward coding (optimize a rate-distortion objective during training; compress motion in one generalizable pass).

4.2. Static-3DGS Foundations

Dynamic methods inherit building blocks from static-3DGS compression. For example, LightGaussian [43] prunes, distills, and vector-quantizes to reach ≈15× at 200+ FPS; Compact-3DGS [44] uses a learnable mask, hash-grid color, and residual VQ (> 25×); EAGLES [45] adds lightweight quantized encodings; PUP 3D-GS [46] replaces heuristic pruning with a principled sensitivity score, a second-order (Fisher-information) approximation of the reconstruction error w.r.t. each Gaussian’s spatial parameters, and a multi-round prune-refine loop, pruning ≈90% of primitives while tripling rendering speed; and HAC [47] introduces context-model coding over Scaffold-GS anchors. The 4D count-reduction methods of Section 4.3 inherit exactly these tools, replacing the heuristic importance scores with learned or sensitivity-based ones.

Spotlight

As highlighted in Figure 11, HAC [47] reframes 3DGS compression as learned entropy coding. It jointly learns a binarized multi-resolution hash grid and, for each Scaffold-GS anchor, queries the grid to obtain a feature that parameterizes a probability distribution over that anchor’s attributes. Those attributes are quantized (an adaptive module sets per-attribute step sizes) and arithmetic-coded against the predicted distribution where the better the prediction the fewer bits spent. This reaches ≈75-100× over vanilla 3DGS and serves as the template that dynamic context coders inherit when adding a time axis. Critique: the method is anchor-bound and adds an encode/decode pass.

4.3. Dynamic / 4D Compression

On the dynamic side, summarized in Table 5 are methods that attack 4D-specific bloat from three angles. The count-reduction camp shrinks the number of primitives: 4DGS-1K [48] prunes short-lifespan Gaussians via a spatial-temporal variation score and skips inactive ones with per-frame active masks (41× storage, 9× faster, 1000+ FPS); OMG4 [42] applies sample/prune/merge plus 4D sub-vector quantization (≈2 GB→3 MB); and MEGA [49] uses an entropy-constrained deformation and opacity-entropy loss with FP16/zip (≈125-190×). The anchor/context camp keeps primitives but shrinks their bits: Light4GS [50] (significance pruning and deep context model, > 120×), ADC-GS [51] (anchor-driven residuals, up to 32×), and TED-4DGS [52] (temporal activation and implicit neural representation (INR) hyperprior). The streaming/online camp targets transmission: QUEEN [53] (inter-frame attribute residuals and quantization-sparsity), 4DGC [54] (rate-aware motion grid), AirGS [55] (ILP-based bandwidth-adaptive pruning), and RDO-4DGS [56] (temporal-smoothness rate-distortion optimization).

Spotlight

As illustrated in Figure 12, a third camp reframes 4DGS compression explicitly as learned video coding, using the structural parallel that a canonical Gaussian set is a reference frame and a deformation field is a set of motion vectors. P-4DGS [57] operationalizes the full intra/inter analogy as follows: intra-frame (spatial) prediction groups nearby canonical Gaussians under a single 3D anchor expanded by an MLP; inter-frame (temporal) prediction is the deformation MLP warping the canonical reference to each timestamp; and adaptive quantization plus context-based entropy coding (the analogue of context-adaptive binary arithmetic coding) codes the residual anchors, reaching ≈1 MB on average, up to 40× (synthetic) and 90× (real) with > 260 FPS. 4DGS-CC [58] applies the same philosophy to the deformation-based 4D Gaussian representation, contextually coding its canonical Gaussians and HexPlane neural voxels (a neural-voxel contextual coding (NVCC) module plus VQ contextual coding (VQCC)) and supporting multi-rate operation to hit a target budget (≈12×). Comparison: the coding camp gives smoother rate-distortion control and graceful multi-rate streaming than raw count reduction, at the cost of an encode/decode stage and an anchor/context backbone. P-4DGS and 4DGS-CC are the dynamic descendants of HAC, adding the temporal axis that it lacks. The three camps increasingly combine anchors for structure, prediction for redundancy, and entropy coding for the last bits, which is why the memory footprint fell from gigabytes to a few megabytes within a year.

4.4. Summary

The reviewed compression methods reveal several cross-cutting trends in how recent 4DGS systems reduce storage while preserving rendering quality.
  • The locus of 4D compression has moved from generic attribute quantization toward temporal redundancy (e.g., short-lifespan pruning, active masks, inter-frame residuals), where 4D-specific bloat lives.
  • Anchor and deep-context models lead the high-compression regime. Deformation pipelines reach tens-of-times reduction, native pipelines two-to-three orders of magnitude.
  • The field is shifting from per-scene optimization to rate-aware training and feed-forward generalizable codecs aimed at true streaming.
  • Cross-method comparison remains an open benchmarking problem. Each paper reports against its own baseline and protocol, hence absolute reduction factors are not directly comparable.

5. Applications

The explicit, real-time nature of 4DGS makes it attractive across many downstream tasks. In this section, we review five application areas.

5.1. Autonomous Driving and Urban Simulation

Driving is the most active application. Methods that decompose the scene into static background and tracked dynamic actors (Section 3.4) are the following: Street Gaussians [31] for editable instance-level simulation; S3Gaussian [27], and DeSiRe-GS [28] for self-supervised static/dynamic separation without boxes; and CoDa-4DGS [59] for semantically aware dynamic modeling. A parallel push targets generalizable driving reconstruction including ADGaussian [39] (ICRA’26), which predicts Gaussians from a single image-plus-LiDAR view, and DrivingScene [38], which performs online reconstruction from two surround-view frames. Both approaches are feed-forward for closed-loop simulation at scale.

5.2. 4D Content Generation

Generative 4D combines diffusion priors, which supply plausible appearance and motion, with explicit Gaussians that supply 3D consistency and fast rendering. Two central paradigms consistently reemerge. Score-distillation approaches lift a 2D/video diffusion model into 4D by optimizing Gaussians. Hence, their renders match the diffusion prior, but pure distillation is slow and prone to the Janus/over-saturation artifacts inherited from text-to-3D. Generation-then-reconstruction approaches instead first synthesize a (multi-view or driving) video and then fit a 4DGS to it, which is faster and more temporally stable. The proceeding spotlight typifies this route.

Spotlight

Figure 13 summarizes the pipeline of DreamGaussian4D [60], an influential image-to-4D technique that cuts generation time from hours to minutes via three choices: a stronger static-3DGS initialization (DreamGaussianHD); learning a HexPlane deformation by fitting a generated driving video rather than an unstable pure-score distillation; and a video-to-video texture refinement that sharpens and temporally stabilizes the result, exportable as an animated mesh. The explicit backbone provides 3D consistency and fast rendering, while diffusion provides appearance/motion priors. Critique: the fidelity is bounded by the driving video’s quality and the results are object-centric. DreamDrive [61] scales the same generation-reconstruction recipe to driving, rendering 3D-consistent videos along arbitrary trajectories from in-the-wild data.

5.3. Editing, Control, and Semantics

Since 4DGS is explicit, it is amenable to manipulation. However, edits must stay consistent across views, time, and the non-edited region.

Spotlight

As illustrated in Figure 14, 4DGS-Craft [62] targets text-instruction-driven interactive 4D editing while enforcing three consistencies that prior editors often break: view consistency, temporal consistency, and non-editing region consistency. It handles comparatively complex instructions, turning a reconstruction into an authoring medium. Critique: the edit fidelity is bounded by the underlying 2D editor and the reconstruction’s quality. A complementary line makes motion controllable (sparse control points with skinning) and lifts language features into the 4D field for open-vocabulary, time-aware understanding and query-driven editing (e.g., 4D LangSplat [63]).

5.4. Beyond RGB: Event-Driven and Constrained Capture

Real data capture often violates the clean, well-exposed, synchronized-RGB assumption.

Spotlight

As depicted in Figure 15, E-4DGS [17] is among the first event-driven 4DGS methods. It reconstructs high-fidelity dynamic scenes from multi-view event-camera streams in the presence of fast camera motion and low light. It contributes event-based initialization, event-adaptive slicing and splatting, intensity-importance pruning to remove floaters, and an adaptive contrast threshold, extending 4DGS to a microsecond-resolution modality that is well suited to high-speed dynamics. Critique: the approach needs a multi-view event rig, and absolute color is harder to recover from events alone. The following related works relax other capture assumptions: Deblur4DGS [64] reconstructs from blurry monocular video by estimating per-object exposure time and GC-4DGS [65] infuses geometric consistency for sparse-input dynamic view synthesis on edge devices.

5.5. Avatars, Robotics, and Medicine

Animatable avatars are the most developed of these domains. Articulated human modeling maps naturally onto 4DGS because a parametric body/face model supplies the motion the Gaussians must follow. For instance, GaussianAvatars [66] rigs each splat to a triangle of a FLAME morphable face mesh and optimizes a per-splat displacement, enabling expression-controlled head reenactment; GAvatar [67] places Gaussians inside pose-driven primitives and predicts their attributes with neural implicit fields to stabilize the learning of millions of splats; Human Gaussian Splatting [68] drives a full-body avatar by linear-blend skinning for real-time rendering; and Expressive Whole-Body Gaussian Avatar [69] jointly models body, hands, and a detailed face. Generative variants such as CAP4D [70] create animatable 4D portrait avatars from a few images via a morphable multi-view diffusion model, connecting this domain to the previously discussed generation methods (Section 5.3). The common pattern is a deformation-based 4DGS (Section 3.2) whose field is constrained by a skeleton or blendshape basis rather than free-form, trading generality for animation control.
Robotics is, by comparison, a nascent direction for 4DGS rather than an established body of work. The explicit, real-time, geometrically-grounded representation is attractive as both a simulation asset and a perception substrate, for photorealistic dynamic mapping and for motion that can be edited and replayed in the loop, yet dedicated 4DGS-for-robotics systems are still few. We refer readers to a survey of this emerging intersection for a fuller treatment [3].
Medicine, especially robot-assisted minimally invasive surgery, is a fast-growing niche. Unlike standard dynamic novel view synthesis benchmarks, endoscopic capture is often monocular or sparsely observed. It contains nonrigid tissue deformation, frequent tool occlusion, view-dependent specularities, and strong illumination changes caused by a light source co-located with the camera. Early works mainly adapt the canonical-plus-deformation design. EndoGS [71], EndoGaussian [72], Deform3DGS [73], and SurgicalGaussian [74] use deformation fields, depth-guided initialization or supervision, and tool-aware masking or regularization to reconstruct deformable tissues in real time. Endo-4DGS [75] is particularly representative for monocular surgical reconstruction by bootstrapping geometry from monocular depth via Depth Anything [76] before compensating for the missing stereo/depth ground truth typical of the surgical domain. ST-Endo4DGS [77] instead models the scene with native, unbiased 4D primitives (anisotropic ellipses with full 4D rotation) for precise spatio-temporal tissue deformation. LGS [78] targets memory and rendering efficiency for resource-limited surgical systems. SurgicalGS [79], EndoPlanar [80], and Surgical Gaussian Surfels [81] emphasize geometric fidelity by improving depth, normal, and surface alignment. Endo-4DGX [82] models uneven illumination with illumination-adaptive Gaussians to handle low-light and over-exposed surgical videos. EndoLRMGS [83] and T2GS [84] no longer treat surgical tools merely as occluders to be masked out, but explicitly reconstruct or model both deformable tissue and instruments within the same scene. Finally, semantic extensions such as FeatureEndo-4DGS [85] augment the Gaussian representation with semantic features, enabling temporally consistent reconstruction and intra-operative segmentation.

5.6. Summary

Across all three domains, the value of 4DGS is real-time, editable, and explicit dynamics. Still, the binding constraint differs: animation control for avatars, replay/closed-loop fidelity for robotics, and monocular, low-texture, deforming capture for medicine. 4DGS is moving from a pure reconstruction representation toward task-specific systems with distinct deployment constraints.
  • Driving is the most mature application and the main impetus of hybrid and feed-forward 4DGS. Editable instance decomposition and closed-loop simulation are distinctive requirements for it.
  • Generation and editing turn 4DGS from a reconstruction format into an authoring medium. Both are bounded by the quality of the 2D/video diffusion priors they build on.
  • Event-based and constrained-capture methods are broadening 4DGS toward robust, in-the-wild capture, an emerging yet fast-growing direction.

6. Open Challenges and Future Directions

Despite rapid progress on 4DGS, several problems remain open. We frame each as a claim, the evidence behind it, and provide an analysis of promising directions.
1.
Storage at scale.Evidence: native 4DGS is extraordinarily heavy on storage usage. A faithful 10-second multi-view clip can exceed 6 GB [33] and an unconstrained RealTime4DGS model is ≈2 GB [42]. Although compression now reaches megabytes (OMG4 2 GB→3 MB [42], 4DGS-1K 41× [48], MEGA 125-190× [49]), these gains are measured on short, single clips. Analysis: hours-long or city-scale capture multiplies this cost linearly because almost every method re-encodes each clip independently. The missing ingredient is structure sharing across time and space, group-of-frames coding [37], bandwidth-aware streaming budgets [55], and priors that exploit the heavy static redundancy of large scenes (Section 3.4) to allow storage to grow with scene novelty rather than with duration.
2.
Monocular ambiguity.Evidence: deformation methods report excellent numbers on the synthetic monocular D-NeRF benchmark. Nonetheless, analyses on real casual capture (e.g., DyCheck/iPhone protocol) show that much of this apparent success comes from quasi-static or “teleporting” cameras that secretly approximate multi-view cues. Under genuine monocular motion, quality drops sharply [86]. Analysis: single-camera dynamic reconstruction is fundamentally under-constrained, depth and motion are entangled. Thus, progress will come less from new rasterizers and more from learned data-driven priors from feed-forward models trained on real monocular video [40], monocular-depth and diffusion priors [20], and physically motivated motion regularizers. Honest monocular benchmarks should be reported alongside D-NeRF rather than instead of it.
3.
Complex, sudden, and topology-changing motion.Evidence: the low-rank HexPlane factorization that makes 4DGaussians efficient also oversimplifies rapid or aperiodic motion, producing blur in fast regions. Native designs cope better. For example, the cubic-polynomial trajectories and temporal-RBF opacity introduced by STG [41] model curved motion and appearing/vanishing content, and 4D-Rotor [24] reaches 277/583 FPS on abrupt motions, but at a storage premium. Analysis: the field still lacks a representation that is simultaneously compact and expressive. Explicit, editable motion bases (e.g., S E ( 3 ) B-spline control points [20]) and adaptive per-region capacity (cheap for static, rich for fast/non-rigid regions, as in hybrid decomposition [29,30]) are the most promising routes.
4.
Long-range temporal stability.Evidence: online methods such as 3DGStream bootstrap each frame from its predecessor via a per-frame transformation cache [36]. Although this keeps per-frame deltas small, it lets errors accumulate causing background flicker and drift over long sequences, which memory-oriented variants explicitly target [87,88]. Analysis: robustness over minutes-to-hours needs mechanisms borrowed from SLAM and video coding, periodic key-frames, global bundle adjustment over Gaussians, loop-closure-style drift correction, and explicit long-term memory, rather than purely causal per-clip fitting.
5.
Generalization and feed-forward 4D.Evidence: the dominant paradigm still optimizes one model per scene, costing minutes to hours. Feed-forward models change this regime, 4DGT [40] reconstructs in seconds from a rolling 64-frame window, and application-specific networks reconstruct driving scenes from one or two views [37,38,39]. Analysis: feed-forward 4D is the likeliest route past the optimization bottleneck, nevertheless three limits remain: in-domain accuracy still trails the best per-scene optimizers; quality depends on accurate input poses and on training-corpus diversity; and the temporal context length is short. Scaling and diversifying training data, pose-free inference, and longer-context architectures are the natural next steps.
6.
Unified benchmarking.Evidence: cross-method numbers in this survey (Table 4 and Table 5) are as reported under each paper’s own protocol, and the confounds are nontrivial. Scene subsets and training schedules are not fixed across papers, and several pipelines rely on per-frame COLMAP for poses while others assume poses are given, none of which is reflected in the headline PSNR/FPS/size figures. Compression ratios in Table 5 compound this problem, since each reduction factor is measured against that paper’s own uncompressed baseline rather than a common reference model, so similar-looking multipliers can start from baselines of very different absolute size. Analysis: closing this gap needs standardized suites that fix data, poses, and hardware, report rate-distortion curves rather than single operating points, and span static/dynamic and NeRF-/Gaussian-based methods under one protocol. Emerging efforts such as Charge [89] are a start, but community adoption and shared, frozen evaluation splits are what will make claims reproducible. Until then, the numbers in Table 4 and Table 5 are best read as order-of-magnitude signals rather than precise rankings.
7.
Beyond RGB and robust real-world capture.Evidence: clean, well-exposed, and synchronized RGB data is the exception in practice. Recent work relaxes this with event cameras for high-speed/low-light scenes [17], blurry monocular video via per-object exposure modeling [64], sparse inputs on edge devices [65], and multi-modal image-plus-LiDAR fusion [39]. Analysis: robust 4DGS should treat imperfect capture as the default, fusing asynchronous, multi-rate, and multi-spectral sensors, and modeling the imaging process (motion blur, rolling shutter, exposure) inside the differentiable pipeline rather than assuming it away.
8.
Semantic, controllable, and editable 4D.Evidence: the explicitness of 4DGS already enables instance-level driving edits [31], text-instruction editing under view/temporal/non-edit consistency [62], and language-grounded, time-aware querying [63]. Analysis: turning reconstructions into authoring media at scale requires open-vocabulary 4D semantics, controllable motion handles (e.g., sparse control points), and edit operations with provable spatio-temporal consistency, an area still bounded by the quality of the 2D/video priors these methods build on.
9.
Physically-grounded dynamics and perceptual metrics.Evidence: most methods fit appearance with photometric losses and report PSNR/SSIM/LPIPS, which reward per-frame fidelity. However, neither enforce physical plausibility (penetration-free, momentum-consistent motion) nor directly measure temporal artifacts such as flicker. Analysis: coupling 4DGS with physics or motion priors and adopting temporal/perceptual quality metrics (e.g., flow-warped consistency, video-quality measures) alongside per-frame PSNR would better align optimization and evaluation with how dynamic reconstructions are actually perceived and used.
10.
Reproducibility.Evidence: beyond the cross-method comparability gap discussed above, many results in this survey are difficult to independently reproduce even in isolation. Code and pretrained weights are not uniformly released alongside publication, when they are, exact training configurations (iteration counts, learning-rate schedules, densification thresholds, random seeds) are often only partially specified in the paper text, and per-scene hyperparameter tuning is common but not always disclosed. Analysis: this compounds the benchmarking gap above, since even a well-designed standardized suite cannot resolve comparisons for methods whose exact configuration is unavailable.

7. Conclusion

This paper has presented a contemporary survey of 4DGS by covering three themes: representations (five families of methods), compression and storage efficiency, and applications. A taxonomy, chronological overviews, and comparative results have been showcased, together with the pros and cons of various approaches and a list of open challenges and future directions. 4DGS has matured remarkably quickly, from gigabyte-per-scene models to megabyte-streamable and even feed-forward reconstructions within roughly two years. Going forward, we expect compression, generalizable inference, and robust real-world capture to define its next phase.

Author Contributions

Thinh Thai and Hieu Phan contributed equally to this work. Thinh Thai and Hieu Phan contributed to the literature review, organization of the surveyed methods, analysis, and preparation of the manuscript. Quang-Anh N. D. contributed to the literature review, analysis, and manuscript preparation. William J. Beksi contributed to the conceptual development, critical review, and revision of the manuscript. Tuan Dang conceived and supervised the study, contributed to its organization and analysis, and reviewed and revised the manuscript. All authors read and approved the final manuscript.

Funding

This research received no specific grant from any funding agency in the public, commercial, or not-for-profit sectors.

Data Availability Statement

No new datasets were generated or analyzed in this study. All data, datasets, and results discussed in this survey are available from the publicly accessible sources cited in the manuscript.

Acknowledgments

Not applicable.

Conflicts of Interest

The authors declare that they have no competing interests.

References

  1. Kerbl, B.; Kopanas, G.; Leimkühler, T.; Drettakis, G. 3D Gaussian Splatting for Real-Time Radiance Field Rendering. ACM Trans. Graph. 2023, 42, 139–1. [Google Scholar] [CrossRef]
  2. Li, T.; Slavcheva, M.; Zollhoefer, M.; Green, S.; Lassner, C.; Kim, C.; Schmidt, T.; Lovegrove, S.; Goesele, M.; Newcombe, R.; et al. Neural 3D Video Synthesis from Multi-view Video. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2022; pp. 5521–5531. [Google Scholar]
  3. Zhu, S.; Wang, G.; Kong, X.; Kong, D.; Wang, H. 3D Gaussian Splatting in Robotics: A Survey. arXiv 2024, arXiv:2410.12262. [Google Scholar]
  4. Zhu, J.; Tang, H. Dynamic Scene Reconstruction: Recent Advance in Real-time Rendering and Streaming. arXiv 2025, arXiv:2503.08166. [Google Scholar]
  5. Youn, S.; Lee, S.; Kim, G.; Kwon, W.; Bae, S.H.; Oh, J. SUCCESS-GS: Survey of Compactness and Compression for Efficient Static and Dynamic Gaussian Splatting. arXiv 2025, arXiv:2512.07197. [Google Scholar]
  6. Ali, M.S.; Zhang, C.; Cagnazzo, M.; Valenzise, G.; Tartaglione, E.; Bae, S.H. Compression in 3D Gaussian splatting: A survey of methods, trends, and future directions. IEEE Transactions on Circuits and Systems for Video Technology, 2026. [Google Scholar]
  7. Zhu, S.; Wang, G.; Kong, X.; Kong, D.; Wang, H. 3D Gaussian splatting in robotics: A survey. arXiv 2024, arXiv:2410.12262. [Google Scholar]
  8. Youn, S.; Lee, S.; Kim, G.; Kwon, W.; Bae, S.H.; Oh, J. SUCCESS-GS: Survey of compactness and compression for efficient static and dynamic Gaussian splatting. arXiv 2025, arXiv:2512.07197. [Google Scholar]
  9. Ali, M.S.; Zhang, C.; Cagnazzo, M.; Valenzise, G.; Tartaglione, E.; Bae, S.H. Compression in 3D Gaussian Splatting: A Survey of Methods, Trends, and Future Directions. IEEE Trans. Circuits Syst. Video Technol. 2026, 36, 9291–9308. [Google Scholar] [CrossRef]
  10. Bagdasarian, M.T.; Knoll, P.; Li, Y.; Barthel, F.; Hilsmann, A.; Eisert, P.; Morgenstern, W. 3DGS.zip: A survey on 3D Gaussian Splatting Compression Methods. Comput. Graph. Forum 2025, 44, e70078. [Google Scholar] [CrossRef]
  11. Chen, G.; Wang, W. A Survey on 3D Gaussian Splatting. ACM Comput. Surv. 2026, 58. [Google Scholar] [CrossRef]
  12. Fei, B.; Xu, J.; Zhang, R.; Zhou, Q.; Yang, W.; He, Y. 3D Gaussian Splatting as a New Era: A Survey. IEEE Trans. Vis. Comput. Graph. 2025, 31, 4429–4449. [Google Scholar] [CrossRef]
  13. Bao, Y.; Ding, T.; Huo, J.; Liu, Y.; Li, Y.; Li, W.; Gao, Y.; Luo, J. 3D Gaussian Splatting: Survey, Technologies, Challenges, and Opportunities. IEEE Trans. Circuits Syst. Video Technol. 2025, 35, 6832–6852. [Google Scholar] [CrossRef]
  14. Zhu, J.; Tang, H. Dynamic scene reconstruction: Recent advance in real-time rendering and streaming. arXiv 2025, arXiv:2503.08166. [Google Scholar]
  15. Cao, Y.; Lu, J.; Huang, Z.; Shen, Z.; Zhao, C.; Hong, F.; Chen, Z.; Li, X.; Wang, W.; Liu, Y.; et al. Reconstructing 4D spatial intelligence: A survey. arXiv 2025, arXiv:2507.21045. [Google Scholar]
  16. Zhao, M.; Nag, S.; Wang, K.; Vora, A.; Ji, G.; Chun, P.; Mahdavi-Amiri, A.; Zhang, H. Advances in 4D Representation: Geometry, Motion, and Interaction. Comput. Graph. Forum n/a, e70582. [CrossRef]
  17. Feng, C.; Tang, Z.; Yu, W.; Pang, Y.; Zhao, Y.; Zhao, J.; Yuan, L.; Tian, Y. E-4DGS: High-Fidelity Dynamic Reconstruction from the Multi-view Event Cameras. In Proceedings of the Proceedings of the ACM International Conference on Multimedia, 2025; pp. 7356–7365. [Google Scholar]
  18. Yang, Z.; Gao, X.; Zhou, W.; Jiao, S.; Zhang, Y.; Jin, X. Deformable 3D Gaussians for High-Fidelity Monocular Dynamic Scene Reconstruction. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 20331–20341. [Google Scholar]
  19. Lu, Z.; Guo, X.; Hui, L.; Chen, T.; Yang, M.; Tang, X.; Zhu, F.; Dai, Y. 3D Geometry-aware Deformable Gaussian Splatting for Dynamic View Synthesis. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 8900–8910. [Google Scholar]
  20. Zhang, X.; Xiao, J.; Huang, S.; Zheng, W.s.; Zhang, Q. Learning Explicit Continuous Motion Representation for Dynamic Gaussian Splatting from Monocular Videos. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026; pp. 33291–33300. [Google Scholar]
  21. Wu, G.; Yi, T.; Fang, J.; Xie, L.; Zhang, X.; Wei, W.; Liu, W.; Tian, Q.; Wang, X. 4D Gaussian Splatting for Real-Time Dynamic Scene Rendering. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 20310–20320. [Google Scholar]
  22. Yang, Z.; Yang, H.; Pan, Z.; Zhang, L. Real-time Photorealistic Dynamic Scene Representation and Rendering with 4D Gaussian Splatting. In Proceedings of the Proceedings of the International Conference on Learning Representations, 2024; pp. 9142–9159. [Google Scholar]
  23. Yang, Z.; Pan, Z.; Zhu, X.; Zhang, L.; Feng, J.; Jiang, Y.G.; Torr, P.H.S. 4D Gaussian Splatting: Modeling Dynamic Scenes with Native 4D Primitives. arXiv 2025, arXiv:2412.20720. [Google Scholar]
  24. Duan, Y.; Wei, F.; Dai, Q.; He, Y.; Chen, W.; Chen, B. 4D-Rotor Gaussian Splatting: Towards Efficient Novel View Synthesis for Dynamic Scenes. In Proceedings of the Proceedings of the ACM SIGGRAPH Conference Papers, 2024; pp. 1–11. [Google Scholar]
  25. Feng, H.; Sun, H.; Xie, W. Disentangled 4D Gaussian Splatting: Rendering High-Resolution Dynamic World at 343 FPS. arXiv 2025, arXiv:2503.22159. [Google Scholar]
  26. Zhou, J.; Yang, Z.; Han, L.; Zhang, W.; Shi, K.; Xu, S.; Liu, Y.S. 4C4D: 4 Camera 4D Gaussian Splatting. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026; pp. 11829–11839. [Google Scholar]
  27. Huang, N.; Wei, X.; Zheng, W.; An, P.; Lu, M.; Zhan, W.; Tomizuka, M.; Keutzer, K.; Zhang, S. S3Gaussian: Self-Supervised Street Gaussians for Autonomous Driving. In Proceedings of the Proceedings of the IEEE International Conference on Robotics and Automation, 2026. [Google Scholar]
  28. Peng, C.; Zhang, C.; Wang, Y.; Xu, C.; Xie, Y.; Zheng, W.; Keutzer, K.; Tomizuka, M.; Zhan, W. DeSiRe-GS: 4D Street Gaussians for Static-Dynamic Decomposition and Surface Reconstruction for Urban Driving Scenes. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025; pp. 6782–6791. [Google Scholar]
  29. Sun, D.; Guan, H.; Zhang, K.; Xie, X.; Zhou, S.K. SDD-4DGS: Static-Dynamic Aware Decoupling in Gaussian Splatting for 4D Scene Reconstruction. arXiv 2025, arXiv:2503.09332. [Google Scholar]
  30. Oh, S.; Lee, Y.; Jeon, H.; Park, E. Hybrid 3D-4D Gaussian Splatting for Fast Dynamic Scene Representation. arXiv 2025, arXiv:2505.13215. [Google Scholar]
  31. Yan, Y.; Lin, H.; Zhou, C.; Wang, W.; Sun, H.; Zhan, K.; Lang, X.; Zhou, X.; Peng, S. Street Gaussians: Modeling Dynamic Urban Scenes with Gaussian Splatting. In Proceedings of the Proceedings of the European Conference on Computer Vision, 2024; pp. 156–173. [Google Scholar]
  32. Lu, T.; Yu, M.; Xu, L.; Xiangli, Y.; Wang, L.; Lin, D.; Dai, B. Scaffold-GS: Structured 3D Gaussians for View-Adaptive Rendering. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 20654–20664. [Google Scholar]
  33. Cho, W.O.; Cho, I.; Kim, S.; Bae, J.; Uh, Y.; Kim, S.J. 4D Scaffold Gaussian Splatting with Dynamic-Aware Anchor Growing for Efficient and High-Fidelity Dynamic Scene Reconstruction. Proc. Proc. AAAI Conf. Artif. Intell. 2026, Vol. 40, 3363–3371. [Google Scholar] [CrossRef]
  34. Li, Y.; Pang, B.; Chen, Y.; Wang, G. Anchored 4D Gaussian Splatting for Dynamic Novel View Synthesis. In Proceedings of the Proceedings of the SIGGRAPH Asia Conference Papers, 2025; pp. 1–11. [Google Scholar]
  35. Yao, W.; Xie, S.; Li, L.; Zhang, W.; Lai, Z.; Dai, S.; Zhang, K.; Wang, Z. SD-GS: Structured Deformable 3D Gaussians for Efficient Dynamic Scene Reconstruction. arXiv 2025, arXiv:2507.07465. [Google Scholar]
  36. Sun, J.; Jiao, H.; Li, G.; Zhang, Z.; Zhao, L.; Xing, W. 3DGStream: On-the-Fly Training of 3D Gaussians for Efficient Streaming of Photo-Realistic Free-Viewpoint Videos. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 20675–20685. [Google Scholar]
  37. Zhang, W.; Zhao, Y.; Wang, Q.; Xu, Z.; Song, L.; Cheng, Z. D-FCGS: Feedforward Compression of Dynamic Gaussian Splatting for Free-Viewpoint Videos. Proc. Proc. AAAI Conf. Artif. Intell. 2026, Vol. 40, 16361–16369. [Google Scholar] [CrossRef]
  38. Hou, Q.; Sun, W.; Zeng, C.; Wang, C.; Li, H.; Cui, J. DrivingScene: A Multi-Task Online Feed-Forward 3D Gaussian Splatting Method for Dynamic Driving Scenes. In Proceedings of the Proceedings of the IEEE International Conference on Acoustics, Speech and Signal Processing, 2026; pp. 10287–10291. [Google Scholar]
  39. Song, Q.; Li, C.; Lin, H.; Peng, S.; Huang, R. ADGaussian: Generalizable Gaussian Splatting for Autonomous Driving via Multi-modal Joint Learning. In Proceedings of the Proceedings of the IEEE International Conference on Robotics and Automation, 2026. [Google Scholar]
  40. Xu, Z.; Li, Z.; Dong, Z.; Zhou, X.; Newcombe, R.; Lv, Z. 4DGT: Learning a 4D Gaussian Transformer Using Real-World Monocular Videos. In Proceedings of the Proceedings of the Advances in Neural Information Processing Systems, 2025. [Google Scholar]
  41. Li, Z.; Chen, Z.; Li, Z.; Xu, Y. Spacetime Gaussian Feature Splatting for Real-Time Dynamic View Synthesis. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 8508–8520. [Google Scholar]
  42. Lee, J.C.; Ko, J.H.; Park, E. Optimized Minimal 3D Gaussian Splatting. Proc. Proc. Adv. Neural Inf. Process. Syst. 2026, Vol. 38, 135864–135888. [Google Scholar]
  43. Fan, Z.; Wang, K.; Wen, K.; Zhu, Z.; Xu, D.; Wang, Z. LightGaussian: Unbounded 3D Gaussian Compression with 15x Reduction and 200+ FPS. Proc. Proc. Adv. Neural Inf. Process. Syst. 2024, Vol. 37, 140138–140158. [Google Scholar] [CrossRef]
  44. Lee, J.C.; Rho, D.; Sun, X.; Ko, J.H.; Park, E. Compact 3D Gaussian Representation for Radiance Field. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 21719–21728. [Google Scholar]
  45. Girish, S.; Gupta, K.; Shrivastava, A. Eagles: Efficient accelerated 3d gaussians with lightweight encodings. In Proceedings of the Proceedings of the European Conference on Computer Vision, 2024; Springer; pp. 54–71. [Google Scholar]
  46. Hanson, A.; Tu, A.; Singla, V.; Jayawardhana, M.; Zwicker, M.; Goldstein, T. PUP 3D-GS: Principled Uncertainty Pruning for 3D Gaussian Splatting. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025; pp. 5949–5958. [Google Scholar]
  47. Chen, Y.; Wu, Q.; Lin, W.; Harandi, M.; Cai, J. Hac: Hash-grid assisted context for 3D Gaussian splatting compression. In Proceedings of the Proceedings of the European Conference on Computer Vision, 2024; Springer; pp. 422–438. [Google Scholar]
  48. Yuan, Y.; Shen, Q.; Yang, X.; Wang, X. 1000+ FPS 4D Gaussian Splatting for Dynamic Scene Rendering. Proc. Proc. Adv. Neural Inf. Process. Syst. 2026, Vol. 38, 74665–74683. [Google Scholar]
  49. Zhang, X.; Liu, Z.; Zhang, Y.; Ge, X.; He, D.; Xu, T.; Wang, Y.; Lin, Z.; Yan, S.; Zhang, J. MEGA: Memory-Efficient 4D Gaussian Splatting for Dynamic Scenes. In Proceedings of the Proceedings of the IEEE/CVF International Conference on Computer Vision, 2025; pp. 27828–27838. [Google Scholar]
  50. Liu, M.; Yang, Q.; Huang, H.; Huang, W.; Yuan, Z.; Li, Z.; Xu, Y.; Guan, Y. Light4GS: Lightweight Compact 4D Gaussian Splatting Generation via Context Model. IEEE Transactions on Circuits and Systems for Video Technology, 2026. [Google Scholar]
  51. Huang, H.; Yang, Q.; Liu, M.; Xu, Y.; Li, Z. ADC-GS: Anchor-Driven Deformable and Compressed Gaussian Splatting for Dynamic Scene Reconstruction. In Proceedings of the Proceedings of the International Joint Conference on Artificial Intelligence, 2025; pp. 1179–1187. [Google Scholar]
  52. Ho, C.Y.; Yang, H.B.; Chiang, J.C.; Liu, Y.L.; Peng, W.H. TED-4DGS: Temporally Activated and Embedding-based Deformation for 4DGS Compression. In Proceedings of the Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, 2026; pp. 6371–6380. [Google Scholar]
  53. Girish, S.; Li, T.; Mazumdar, A.; Shrivastava, A.; Luebke, D.; De Mello, S. Queen: Quantized efficient encoding of dynamic gaussians for streaming free-viewpoint videos. Proc. Proc. Adv. Neural Inf. Process. Syst. 2024, Vol. 37, 43435–43467. [Google Scholar] [CrossRef]
  54. Hu, Q.; Zheng, Z.; Zhong, H.; Fu, S.; Song, L.; Zhang, X.; Zhai, G.; Wang, Y. 4DGC: Rate-Aware 4D Gaussian Compression for Efficient Streamable Free-Viewpoint Video. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025; pp. 875–885. [Google Scholar]
  55. Wang, Z.; Li, J.; Zhu, Y. AirGS: Real-Time 4D Gaussian Streaming for Free-Viewpoint Video Experiences. arXiv 2025, arXiv:2512.20943. [Google Scholar]
  56. Lee, H.; Baek, K. Temporal Smoothness-Aware Rate-Distortion Optimized 4D Gaussian Splatting. Proc. Proc. Adv. Neural Inf. Process. Syst. 2026, Vol. 38, 132174–132204. [Google Scholar]
  57. Wang, H.; Zhu, H.; Gong, X.; He, T.; Li, X.; Chen, Z. P-4DGS: Predictive 4D Gaussian Splatting with 90× Compression. arXiv 2025, arXiv:2510.10030. [Google Scholar]
  58. Chen, Z.; Chen, Z.; Jiang, W.; Wang, W.; Liu, L.; Xu, D. 4DGS-CC: A Contextual Coding Framework for 4D Gaussian Splatting Data Compression. arXiv 2025, arXiv:2504.18925. [Google Scholar]
  59. Song, R.; Liang, C.; Xia, Y.; Zimmer, W.; Cao, H.; Caesar, H.; Festag, A.; Knoll, A. CoDa-4DGS: Dynamic Gaussian Splatting with Context and Deformation Awareness for Autonomous Driving. In Proceedings of the Proceedings of the IEEE/CVF International Conference on Computer Vision, 2025; pp. 28031–28041. [Google Scholar]
  60. Ren, J.; Pan, L.; Tang, J.; Zhang, C.; Cao, A.; Zeng, G.; Liu, Z. DreamGaussian4D: Generative 4D Gaussian Splatting. arXiv 2023, arXiv:2312.17142. [Google Scholar]
  61. Mao, J.; Li, B.; Ivanovic, B.; Chen, Y.; Wang, Y.; You, Y.; Xiao, C.; Xu, D.; Pavone, M.; Wang, Y. DreamDrive: Generative 4D Scene Modeling from Street View Images. In Proceedings of the Proceedings of the IEEE International Conference on Robotics and Automation, 2025; pp. 367–374. [Google Scholar]
  62. Liu, L.; Wang, C.; Chen, Z.; Liu, Z.; Xu, D. 4DGS-Craft: Consistent and Interactive 4D Gaussian Splatting Editing. IEEE Transactions on Circuits and Systems for Video Technology, 2026. [Google Scholar]
  63. Li, W.; Zhou, R.; Zhou, J.; Song, Y.; Herter, J.; Qin, M.; Huang, G.; Pfister, H. 4D LangSplat: 4D Language Gaussian Splatting via Multimodal Large Language Models. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025; pp. 22001–22011. [Google Scholar]
  64. Wu, R.; Zhang, Z.; Chen, M.; Yan, Z.; Zuo, W. Deblur4DGS: 4D Gaussian Splatting from Blurry Monocular Video. Proc. Proc. AAAI Conf. Artif. Intell. 2026, Vol. 40, 10727–10735. [Google Scholar] [CrossRef]
  65. Li, Y.; Cao, J.; Ruan, P.; Saxena, D.; Zhu, S.; Cao, Y. Geometry-Consistent 4D Gaussian Splatting for Sparse-Input Dynamic View Synthesis. arXiv 2025, arXiv:2511.23044. [Google Scholar]
  66. Qian, S.; Kirschstein, T.; Schoneveld, L.; Davoli, D.; Giebenhain, S.; Nießner, M. GaussianAvatars: Photorealistic Head Avatars with Rigged 3D Gaussians. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 20299–20309. [Google Scholar]
  67. Yuan, Y.; Li, X.; Huang, Y.; De Mello, S.; Nagano, K.; Kautz, J.; Iqbal, U. GAvatar: Animatable 3D Gaussian Avatars with Implicit Mesh Learning. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 896–905. [Google Scholar]
  68. Moreau, A.; Song, J.; Dhamo, H.; Shaw, R.; Zhou, Y.; Pérez-Pellitero, E. Human Gaussian Splatting: Real-time Rendering of Animatable Avatars. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 788–798. [Google Scholar]
  69. Moon, G.; Shiratori, T.; Saito, S. Expressive Whole-Body 3D Gaussian Avatar. In Proceedings of the Proceedings of the European Conference on Computer Vision, 2024; pp. 19–35. [Google Scholar]
  70. Taubner, F.; Zhang, R.; Tuli, M.; Lindell, D.B. CAP4D: Creating Animatable 4D Portrait Avatars with Morphable Multi-View Diffusion Models. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025; pp. 5318–5330. [Google Scholar]
  71. Zhu, L.; Wang, Z.; Cui, J.; Jin, Z.; Lin, G.; Yu, L. EndoGS: Deformable Endoscopic Tissues Reconstruction with Gaussian Splatting. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2024; pp. 135–145. [Google Scholar]
  72. Liu, Y.; Li, C.; Yang, C.; Yuan, Y. EndoGaussian: Real-time Gaussian Splatting for Dynamic Endoscopic Scene Reconstruction. arXiv 2024, arXiv:2401.12561. [Google Scholar]
  73. Yang, S.; Li, Q.; Shen, D.; Gong, B.; Dou, Q.; Jin, Y. Deform3DGS: Flexible Deformation for Fast Surgical Scene Reconstruction with Gaussian Splatting. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2024; pp. 132–142. [Google Scholar]
  74. Xie, W.; Yao, J.; Cao, X.; Lin, Q.; Tang, Z.; Dong, X.; Guo, X. SurgicalGaussian: Deformable 3D Gaussians for High-Fidelity Surgical Scene Reconstruction. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2024; pp. 617–627. [Google Scholar]
  75. Huang, Y.; Cui, B.; Bai, L.; Guo, Z.; Xu, M.; Islam, M.; Ren, H. Endo-4DGS: Endoscopic Monocular Scene Reconstruction with 4D Gaussian Splatting. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2024; pp. 197–207. [Google Scholar]
  76. Yang, L.; Kang, B.; Huang, Z.; Xu, X.; Feng, J.; Zhao, H. Depth Anything: Unleashing the Power of Large-Scale Unlabeled Data. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2024; pp. 10371–10381. [Google Scholar]
  77. Li, F.; He, J.; Ma, J.; Wu, Z. Real-Time Spatio-Temporal Reconstruction of Dynamic Endoscopic Scenes with 4D Gaussian Splatting. In Proceedings of the Proceedings of the IEEE International Symposium on Biomedical Imaging, 2025; pp. 1–5. [Google Scholar]
  78. Liu, H.; Liu, Y.; Li, C.; Li, W.; Yuan, Y. LGS: A Light-weight 4D Gaussian Splatting for Efficient Surgical Scene Reconstruction. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2024; pp. 660–670. [Google Scholar]
  79. Chen, J.; Zhang, X.; Hoque, M.I.; Vasconcelos, F.; Stoyanov, D.; Elson, D.S.; Huang, B. SurgicalGS: Dynamic 3D Gaussian Splatting for Accurate Robotic-Assisted Surgical Scene Reconstruction. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2025; pp. 572–582. [Google Scholar]
  80. Paonim, T.; Sasnarukkit, C.; Nupairoj, N.; Vateekul, P. EndoPlanar: Deformable Planar-based Gaussian Splatting for Surgical Scene Reconstruction. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2025; pp. 127–136. [Google Scholar]
  81. Sunmola, I.O.; Zhao, Z.; Schmidgall, S.; Wang, Y.; Scheikl, P.M.; Pham, V.; Krieger, A. Surgical Gaussian Surfels: Highly Accurate Real-time Surgical Scene Rendering using Gaussian Surfels. In Proceedings of the Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, 2026; pp. 4515–4524. [Google Scholar]
  82. Huang, Y.; Bai, L.; Cui, B.; Li, Y.; Chen, T.; Wang, J.; Wu, J.; Lei, Z.; Liu, H.; Ren, H. Endo-4DGX: Robust Endoscopic Scene Reconstruction and Illumination Correction with Gaussian Splatting. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2025; pp. 181–191. [Google Scholar]
  83. Wang, X.; Zhang, S.; Huang, B.; Stoyanov, D.; Mazomenos, E.B. EndoLRMGS: Combining Large Reconstruction Modelling and Gaussian Splatting for Complete Endoscopic Scene Reconstruction. IEEE Transactions on Medical Imaging, 2026. [Google Scholar]
  84. Xu, J.; Li, C.; Liu, P.; Pfeiffer, M.; Liu, L.; Docea, R.; Wagner, M.; Speidel, S. T2GS: Comprehensive Reconstruction of Dynamic Surgical Scenes with Gaussian Splatting. In Proceedings of the Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention, 2025; pp. 595–605. [Google Scholar]
  85. Li, K.; Wang, J.; Han, W.; Zhao, D. FeatureEndo-4DGS: Real-Time Deformable Surgical Scene Reconstruction and Segmentation with 4D Gaussian Splatting. In Proceedings of the Proceedings of Machine Learning Research, 2026; pp. 1218–1234. [Google Scholar]
  86. Liang, Y.; Okunev, M.; Uy, M.A.; Li, R.; Guibas, L.; Tompkin, J.; Harley, A.W. Monocular Dynamic Gaussian Splatting: Fast, Brittle, and Scene Complexity Rules. arXiv 2024, arXiv:2412.04457. [Google Scholar]
  87. Lee, W.; Woo, S.; Kim, D.; Lee, J.; Park, S.; Lee, S. MoRGS: Efficient Per-Gaussian Motion Reasoning for Streamable Dynamic 3D Scenes. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026; pp. 41044–41053. [Google Scholar]
  88. Kwak, S.; Kwon, W.; Jeong, J.Y.; Kim, G.; Cheong, W.S.; Oh, J. MoRel: Long-Range Flicker-Free 4D Motion Modeling via Anchor Relay-based Bidirectional Blending with Hierarchical Densification. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026; pp. 37370–37379. [Google Scholar]
  89. Nazarczuk, M.; Tanay, T.; Moreau, A.; Zhang, Z.; Pérez-Pellitero, E. Charge: A Comprehensive Novel View Synthesis Benchmark and Dataset to Bind Them All. In Proceedings of the Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2026; pp. 15323–15333. [Google Scholar]
Figure 1. A taxonomy of 4DGS. The field is organized along three themes: representations (how time is modeled), compression (how storage is reduced), and applications. The colors denote the five representation families and the compression/application groups used throughout the paper.
Figure 1. A taxonomy of 4DGS. The field is organized along three themes: representations (how time is modeled), compression (how storage is reduced), and applications. The colors denote the five representation families and the compression/application groups used throughout the paper.
Preprints 241558 g001
Figure 2. An end-to-end 4DGS pipeline. Data captured under one of several regimes (left; cf. Figure 3) is reduced to posed frames and a structure from motion point cloud. The data is then lifted into a 4D representation by one of the five families of methods surveyed (e.g., deformation, native 4D, hybrid, anchor/streaming, or feed-forward (§Section 3)) and rendered by differentiable rasterization into novel views across time. The first four families optimize a photometric loss per scene. The feed-forward family instead predicts the representation in a single network pass.
Figure 2. An end-to-end 4DGS pipeline. Data captured under one of several regimes (left; cf. Figure 3) is reduced to posed frames and a structure from motion point cloud. The data is then lifted into a 4D representation by one of the five families of methods surveyed (e.g., deformation, native 4D, hybrid, anchor/streaming, or feed-forward (§Section 3)) and rendered by differentiable rasterization into novel views across time. The first four families optimize a photometric loss per scene. The feed-forward family instead predicts the representation in a single network pass.
Preprints 241558 g002
Figure 3. The different capture regimes for 4DGS datasets. From left to right: a synthetic object with a single orbiting camera (D-NeRF); a real monocular handheld capture (HyperNeRF, NeRF-DS); a synchronized multi-view camera rig around a dynamic scene (Neural 3D Video, Technicolor); a vehicle with RGB cameras and LiDAR in an outdoor driving scene (KITTI, Waymo, nuScenes); a multi-view event-camera rig for high-speed/low-light dynamics (E-4DGS). The capture regime largely determines which method is applicable.
Figure 3. The different capture regimes for 4DGS datasets. From left to right: a synthetic object with a single orbiting camera (D-NeRF); a real monocular handheld capture (HyperNeRF, NeRF-DS); a synchronized multi-view camera rig around a dynamic scene (Neural 3D Video, Technicolor); a vehicle with RGB cameras and LiDAR in an outdoor driving scene (KITTI, Waymo, nuScenes); a multi-view event-camera rig for high-speed/low-light dynamics (E-4DGS). The capture regime largely determines which method is applicable.
Preprints 241558 g003
Figure 4. A chronological overview of representative 4DGS methods (2023–2026), color-coded by family. The compression and application works are shown in red and gray, while the three representational families and the anchor/streaming and feed-forward families use the colors of Figure 1. The methods are organized by first-arXiv year.
Figure 4. A chronological overview of representative 4DGS methods (2023–2026), color-coded by family. The compression and application works are shown in red and gray, while the three representational families and the anchor/streaming and feed-forward families use the colors of Figure 1. The methods are organized by first-arXiv year.
Preprints 241558 g004
Figure 5. In 4DGaussians [21], a canonical Gaussian set is warped by a HexPlane-decomposed 4D feature volume (six multi-resolution planes) and a tiny multi-head MLP, and then rasterized by the unmodified 3DGS pipeline.
Figure 5. In 4DGaussians [21], a canonical Gaussian set is warped by a HexPlane-decomposed 4D feature volume (six multi-resolution planes) and a tiny multi-head MLP, and then rasterized by the unmodified 3DGS pipeline.
Preprints 241558 g005
Figure 6. From a sparse four-camera video, 4C4D [26] initializes native 4D Gaussians via a dense point cloud. Then, a lightweight neural decaying function f θ predicts a per-Gaussian opacity-decay factor γ i that gates the opacity entering differentiable rasterization. This allows the joint photometric backprop to be steered toward geometry rather than appearance.
Figure 6. From a sparse four-camera video, 4C4D [26] initializes native 4D Gaussians via a dense point cloud. Then, a lightweight neural decaying function f θ predicts a per-Gaussian opacity-decay factor γ i that gates the opacity entering differentiable rasterization. This allows the joint photometric backprop to be steered toward geometry rather than appearance.
Preprints 241558 g006
Figure 7. Street Gaussians [31] consists of a static-background 3DGS plus per-object models in their own frames with optimized 6-DoF pose trajectories and time-dependent appearance. The explicit decomposition makes the scene editable for closed-loop driving simulation.
Figure 7. Street Gaussians [31] consists of a static-background 3DGS plus per-object models in their own frames with optimized 6-DoF pose trajectories and time-dependent appearance. The explicit decomposition makes the scene editable for closed-loop driving simulation.
Preprints 241558 g007
Figure 8. 3DGStream [36] is an online two-stage method where Stage 1 fits a neural transformation cache (NTC) (hash grid + MLP) to predict a per-Gaussian translation/rotation from the previous frame and Stage 2 spawns a few frame-specific Gaussians for emerging content.
Figure 8. 3DGStream [36] is an online two-stage method where Stage 1 fits a neural transformation cache (NTC) (hash grid + MLP) to predict a per-Gaussian translation/rotation from the previous frame and Stage 2 spawns a few frame-specific Gaussians for emerging content.
Preprints 241558 g008
Figure 9. 4DGT [40] consists of a feed-forward 4D Gaussian transformer that maps a rolling window of 64 posed monocular frames directly to 4D Gaussians in a single pass, unifying static and dynamic content via varying primitive lifespans.
Figure 9. 4DGT [40] consists of a feed-forward 4D Gaussian transformer that maps a rolling window of 64 posed monocular frames directly to 4D Gaussians in a single pass, unifying static and dynamic content via varying primitive lifespans.
Preprints 241558 g009
Figure 10. A generic 4DGS compression pipeline. A trained model is reduced, compacted, quantized, and entropy-coded into a bitstream. Two cross-cutting mechanisms feed it: structured/anchor prediction replaces explicit storage with neural prediction and a learned context model while temporal-redundancy modeling exploits correlations over time. Rate-aware training closes the loop by optimizing distortion against bitrate.
Figure 10. A generic 4DGS compression pipeline. A trained model is reduced, compacted, quantized, and entropy-coded into a bitstream. Two cross-cutting mechanisms feed it: structured/anchor prediction replaces explicit storage with neural prediction and a learned context model while temporal-redundancy modeling exploits correlations over time. Rate-aware training closes the loop by optimizing distortion against bitrate.
Preprints 241558 g010
Figure 11. HAC [47] consists of a learned hash grid that predicts, per anchor, a probability distribution over its (quantized) attributes. These attributes are then arithmetic-coded. The better the prediction, the fewer bits used. It is the template that dynamic context coders extend with a time axis.
Figure 11. HAC [47] consists of a learned hash grid that predicts, per anchor, a probability distribution over its (quantized) attributes. These attributes are then arithmetic-coded. The better the prediction, the fewer bits used. It is the template that dynamic context coders extend with a time axis.
Preprints 241558 g011
Figure 12. From a video-codec view (P-4DGS [57], 4DGS-CC [58]), the canonical set acts as a reference frame, anchor prediction as intra-frame prediction, and the deformation field as inter-frame motion vectors. A context-based entropy coder codes the residuals to a tiny bitstream.
Figure 12. From a video-codec view (P-4DGS [57], 4DGS-CC [58]), the canonical set acts as a reference frame, anchor prediction as intra-frame prediction, and the deformation field as inter-frame motion vectors. A context-based entropy coder codes the residuals to a tiny bitstream.
Preprints 241558 g012
Figure 13. DreamGaussian4D [60] is comprised of image-to-4D generation, a static 3DGS initialization, a HexPlane deformation learned by fitting a generated driving video, and a video-to-video texture refinement exported as an animated mesh.
Figure 13. DreamGaussian4D [60] is comprised of image-to-4D generation, a static 3DGS initialization, a HexPlane deformation learned by fitting a generated driving video, and a video-to-video texture refinement exported as an animated mesh.
Preprints 241558 g013
Figure 14. 4DGS-Craft [62] employs text-instruction-driven interactive 4D editing. A 2D diffusion editor is propagated through the 4D field under view, temporal, and non-editing region consistency constraints.
Figure 14. 4DGS-Craft [62] employs text-instruction-driven interactive 4D editing. A 2D diffusion editor is propagated through the 4D field under view, temporal, and non-editing region consistency constraints.
Preprints 241558 g014
Figure 15. E-4DGS [17] utilizes event-based initialization, event-adaptive slicing and splatting for time-aware reconstruction, and intensity-importance pruning to remove floaters under fast motion and low-light conditions.
Figure 15. E-4DGS [17] utilizes event-based initialization, event-adaptive slicing and splatting for time-aware reconstruction, and intensity-importance pruning to remove floaters under fast motion and low-light conditions.
Preprints 241558 g015
Table 1. Comparison with existing surveys on 3D/4D Gaussian splatting and related fields. ● = systematic, dedicated coverage; ◐ = partial or lens-limited coverage; ○ = not covered as an organizing axis.
Table 1. Comparison with existing surveys on 3D/4D Gaussian splatting and related fields. ● = systematic, dedicated coverage; ◐ = partial or lens-limited coverage; ○ = not covered as an organizing axis.
Survey Year Primary scope 4DGS family taxonomy Compression Applications
Zhu et al. [7] 2024 Static 3DGS for robotics ○ ◐ Robotics only
Zhu & Tang [14] 2025 Dynamic scenes, NeRF + 3DGS, rendering/streaming ◐ ○ Volumetric video, AR/VR only
Youn et al. [8] 2025 Compression/efficiency, static + dynamic GS ◐ ● Named only, no dedicated sections
Ali et al. [9] 2025 Static 3DGS compression only ○ ● Motivation only
Chen & Wang [11] 2026 General 3DGS: principles, 7 improvement directions, dynamic-scene subsection ◐ ◐ Broad: robotics, dynamic recon., gen./editing, avatar, endoscopy, large-scale, physics
Fei et al. [12] 2024 General 3DGS: representation, reconstruction, manipulation, generation, perception, virtual humans ◐ ◐ Broad: detection, segmentation, tracking, SLAM, human bodies/heads
Bao et al. [13] 2025 General static 3DGS ◐ ◐ Broad
Bagdasarian et al. [10] 2025 Static 3DGS compression only ○ ● Motivation only
Cao et al. [15] 2025 Representation-agnostic 4D reconstruction, five capability levels ○ ○ Broad, not GS-specific
Zhao et al. [16] 2025 Representation-agnostic 4D generation + reconstruction ○ ○ Broad, not GS-specific
Ours 2026 Dynamic/4D Gaussian splatting for reconstruction ● ● Driving, 4D generation, editing, event capture, avatars/robotics/medicine
Table 2. A summary of representative datasets used to evaluate 4DGS. “MV” = multi-view, “Mono” = monocular. Frame/view counts are typically orders of magnitude apart and many sets contain several scenes of varying lengths.
Table 2. A summary of representative datasets used to evaluate 4DGS. “MV” = multi-view, “Mono” = monocular. Frame/view counts are typically orders of magnitude apart and many sets contain several scenes of varying lengths.
Dataset Year Capture Type Modality / sensor Primary use
D-NeRF 2020 Mono (synthetic) Synthetic RGB Object deformation, monocular novel view synthesis (NVS)
HyperNeRF 2021 Mono Real RGB Topology-changing monocular NVS
NeRF-DS 2023 Mono Real RGB Specular/deforming monocular NVS
Neural 3D Video (Plenoptic) [2] 2022 MV (rig) Real RGB (15-21 cameras) Volumetric video, standard MV NVS
Technicolor 2017 MV (rig) Real RGB (4×4) Volumetric video, high resolution
Google Immersive 2020 MV (rig) Real RGB (fish-eye) Immersive light-field video
KITTI 2012 Vehicle Real RGB + LiDAR Driving NVS / detection
Waymo Open 2020 Vehicle Real RGB + LiDAR Large-scale driving simulation
nuScenes 2020 Vehicle Real RGB + LiDAR Surround-view driving
Multi-view event rig  [17] 2025 MV Real Events High-speed / low-light dynamics
Table 3. Five families of 4DGS methods and their trade-offs.
Table 3. Five families of 4DGS methods and their trade-offs.
Family Core idea Strengths Weaknesses
Deformation-based Canonical 3D set and time-conditioned deformation field Compact; smooth motion; monocular-friendly Sudden motion, topology change; often slower
Native 4D-primitive Gaussians live in 4D space-time / carry temporal parameters Top quality; very fast rendering; transient content Large storage; many primitives
Hybrid / decomposition Split static vs. dynamic; 3D for static, 4D for moving Efficient; editable; suits driving Needs a separation mechanism
Anchor / scaffold & streaming Predict Gaussians from sparse anchors; model frames incrementally Strong storage reduction; long video Added architectural complexity
Feed-forward / generalizable A network maps video to 4D Gaussians in one pass Seconds not hours; no per-scene fit Bounded by training data; needs poses
Table 5. Representative compression methods for Gaussian splatting. Reductions are as reported by each paper under its own protocol, hence indicative. “Deform.” = canonical + deformation; “Native” = space-time primitives.
Table 5. Representative compression methods for Gaussian splatting. Reductions are as reported by each paper under its own protocol, hence indicative. “Deform.” = canonical + deformation; “Native” = space-time primitives.
Method Base Key technique(s) Reported efficiency
Static-3DGS foundations
LightGaussian [43] Static prune + distill + VecTree VQ ≈15×, 200+ FPS
Compact-3DGS [44] Static learnable mask + hash color + residual VQ >25× vs 3DGS
HAC [47] Static hash-grid context + entropy coding (Scaffold-GS) up to ≈100×
Dynamic / 4D
QUEEN [53] Online FVV inter-frame attribute residuals + quant.-sparsity competitive online FVV
4DGC [54] Native motion grid + sparse compensation, rate-aware streamable, strong RD
P-4DGS [57] Deform. intra/inter prediction (anchors + deform.) + entropy ≈1 MB, 40–90×, 260+ FPS
4DGS-CC [58] Deform. contextual coding of voxels (NVCC) + VQCC, multi-rate ≈12× (rate-controllable)
ADC-GS [51] Deform. anchor-driven residuals + hierarchical motion up to 32× (HyperNeRF)
Light4GS [50] Deform. significance pruning + deep context model >120×, +20% FPS
4DGS-1K [48] Native spatio-temporal pruning + active masks 41×, 9× faster, 1000+ FPS
MEGA [49] Native entropy-constrained deform. + opacity entropy + FP16/zip ≈125–190× vs 4DGS
OMG4 [42] Native sample/prune/merge + 4D sub-vector quant. 2 GB→≈3 MB
TED-4DGS [52] Scaffold temporal activation + INR hyperprior RD-competitive
RDO-4DGS [56] Native temporal-smoothness rate–distortion optimization RD-optimized
D-FCGS [37] Feed-fwd GoF I-P coding, single-pass motion coding generalizable, no per-scene opt.
AirGS [55] Streaming ILP-based adaptive pruning for bandwidth bandwidth-adaptive
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.