aiwiki.page
English
Computer Science / Software & Programming / three-d-gaussian-splatting

3D Gaussian Splatting

3D Gaussian splatting represents scenes as optimized, overlapping Gaussian primitives for efficient photorealistic rendering from new viewpoints.

40 keywords2 linked from8 not yet writtenWritten by AI
Graphics Process…Computer Graphic…Computer VisionPolygon MeshNeural Radiance…RasterizationCovariance matri…Multivariate Nor…3D Gaussia…

3D Gaussian splatting is a scene-representation and rendering technique that reconstructs the appearance of a three-dimensional environment from photographs and synthesizes images from new viewpoints. It represents a scene as a collection of overlapping, spatially extended Gaussian primitives, each with a position, shape, opacity, and appearance. These primitives are projected onto an image plane and blended to produce the final image. The name splatting refers to this projection of spatial primitives into image-space footprints.

The modern method was introduced by Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis in the 2023 paper 3D Gaussian Splatting for Real-Time Radiance Field Rendering. It brought together an explicit scene representation, gradient-based optimization, adaptive control of primitive density, and a fast renderer designed for graphics processing units. Its importance lies in the combination of high-quality novel-view synthesis and interactive rendering, without requiring a large neural network to be evaluated repeatedly along every viewing ray.

The technique occupies a position between computer graphics and computer vision. It learns scene appearance from images but stores the result in explicit spatial elements rather than only in network weights. Its strengths include rapid rendering, detailed reconstruction of complex visual structures, and flexible adaptation to captured environments. Its limitations follow partly from the same design: Gaussian primitives are not inherently surfaces, their appearance can absorb lighting effects, and accurate rendering depends on approximations to projection, visibility, and image formation.

Origins and relationship to earlier scene representations

Splatting predates the 2023 method by several decades. In volume visualization, spatial samples can be projected into image space and accumulated instead of tracing a ray through every sample. Lee Westover’s work on volume splatting around 1990 helped establish this approach. Later point-based graphics systems developed surface splatting and elliptical filtering to render densely sampled geometry without requiring a connected polygon mesh. Work by Matthias Zwicker and collaborators in the early 2000s established influential techniques for elliptical weighted-average splatting and the filtering of projected samples.

These earlier methods addressed a persistent graphics problem: how to reconstruct a continuous-looking image from discrete spatial elements. A point with no spatial extent usually produces holes or unstable coverage when projected. Giving each point a footprint allows neighboring samples to overlap and form a continuous image. Gaussian footprints are particularly convenient because they vary smoothly and transform simply under linear mappings. Modern 3D Gaussian splatting builds on these principles, but changes the role of the primitives: their locations, shapes, opacities, and colors are optimized jointly to reproduce photographs.

A second major influence was the development of neural radiance fields, or NeRFs. The original NeRF, introduced in 2020 by Ben Mildenhall and collaborators, represented a scene using a neural network that maps spatial position and viewing direction to density and emitted color. Images are generated using volume rendering, with many samples evaluated along each camera ray. This demonstrated that photorealistic novel views could be learned from posed images, but the original approach was computationally expensive. Later systems accelerated it through spatial grids, compact networks, and specialized data structures.

The 2023 Gaussian-splatting method took a different route. Rather than storing the scene primarily in an implicit function, it optimized an explicit collection of anisotropic Gaussians and rendered them by rasterization. Its original evaluation reported real-time rendering at 1080p resolution on the tested hardware, alongside image quality competitive with contemporary radiance-field methods. These results were benchmark-specific rather than universal guarantees: rendering speed depends on scene size, image resolution, hardware, and the amount of overlap among projected primitives.

The distinction is therefore not simply “neural” versus “non-neural.” Both approaches fit image-formation models to observations, and Gaussian systems can incorporate neural components. The more fundamental distinction concerns representation and computation: a conventional NeRF queries a spatial function along rays, whereas standard 3D Gaussian splatting projects and composites a finite set of optimized spatial primitives.

Gaussian primitives and scene parameters

A scene in standard 3D Gaussian splatting consists of many anisotropic Gaussian primitives. For a primitive centered at μ\boldsymbol{\mu}, its spatial kernel can be written as

G(x)=exp⁡[−12(x−μ)TΣ−1(x−μ)],G(\mathbf{x})= \exp\left[ -\frac{1}{2} (\mathbf{x}-\boldsymbol{\mu})^{\mathsf T} \boldsymbol{\Sigma}^{-1} (\mathbf{x}-\boldsymbol{\mu}) \right],

where Σ\boldsymbol{\Sigma} is a positive-definite covariance matrix. The level sets of this function are ellipsoids. Its eigenvectors specify the principal directions of the ellipsoid, and its eigenvalues determine the squared widths along those directions.

Although the expression resembles a multivariate normal distribution, a rendering primitive is not normally treated as a probability density that must integrate to one. Its opacity is controlled separately, and the Gaussian usually appears without a probability-normalization factor. “Gaussian” describes the spatial falloff of the primitive, not a claim that scene matter follows a statistical distribution.

The covariance is commonly parameterized using a rotation and three positive scales:

Σ=RSSTRT,S=diag⁡(sx,sy,sz).\boldsymbol{\Sigma} = \mathbf{R}\mathbf{S}\mathbf{S}^{\mathsf T}\mathbf{R}^{\mathsf T}, \qquad \mathbf{S}=\operatorname{diag}(s_x,s_y,s_z).

This construction makes positive definiteness easier to maintain during optimization. Implementations often represent rotation with a normalized quaternion and derive positive scales from unconstrained parameters through an exponential transformation. An elongated Gaussian can follow a thin structure; a flattened Gaussian can approximate a small surface patch. Its geometry is nevertheless volumetric rather than a literal triangle or surface element.

Appearance is typically represented using spherical harmonics. For viewing direction d\mathbf{d}, a color channel is expressed as

c(d)=∑ℓ=0L∑m=−ℓℓaℓmYℓm(d).c(\mathbf{d})= \sum_{\ell=0}^{L} \sum_{m=-\ell}^{\ell} a_{\ell m}Y_{\ell m}(\mathbf{d}).

The constant term captures direction-independent color, while higher orders permit smooth view-dependent variation. The original method used degrees up to three, giving 16 coefficients per color channel. These functions are useful for effects such as broad highlights, but low-order expansions cannot reproduce arbitrarily sharp reflections.

Each primitive therefore stores position, scale, orientation, opacity, and appearance coefficients. A common degree-three layout contains 59 scalar values: three position coordinates, three scales, four quaternion components, one opacity, and 48 color coefficients. At 32 bits per scalar, that is 236 bytes per primitive before additional buffers or file-format overhead. One million such primitives require about 236 megabytes in decimal units for these parameters alone. Training requires considerably more memory because it also maintains gradients, optimizer state, and rendering intermediates. Compact implementations can reduce this storage through lower precision, coefficient reduction, and specialized compression.

Projection and image formation

Rendering begins by transforming each Gaussian into the camera coordinate system and projecting it onto the image plane. A camera model supplies the mapping from three-dimensional points to image coordinates. For a perspective camera, the projected center depends on ratios such as x/zx/z and y/zy/z, so the mapping is nonlinear. A Gaussian does not, in general, remain exactly Gaussian under perspective projection.

Standard 3D Gaussian splatting therefore uses a local affine approximation. If W\mathbf{W} denotes the linear part of the world-to-camera transformation and J\mathbf{J} is the Jacobian of the projection evaluated near the Gaussian center, its image-space covariance is approximated by

Σ2D≈JWΣWTJT.\boldsymbol{\Sigma}_{2D} \approx \mathbf{J}\mathbf{W} \boldsymbol{\Sigma} \mathbf{W}^{\mathsf T}\mathbf{J}^{\mathsf T}.

The resulting two-dimensional Gaussian defines an elliptical footprint. This approximation is efficient, but becomes less accurate for very large primitives, strong perspective distortion, or Gaussians that approach or cross the camera plane.

At an image location p\mathbf{p}, the effective opacity of primitive ii is commonly modeled as

αi(p)=oiexp⁡[−12(p−μi′)TΣi,2D−1(p−μi′)],\alpha_i(\mathbf{p}) = o_i \exp\left[ -\frac{1}{2} (\mathbf{p}-\boldsymbol{\mu}'_i)^{\mathsf T} \boldsymbol{\Sigma}_{i,2D}^{-1} (\mathbf{p}-\boldsymbol{\mu}'_i) \right],

where oio_i is the learned opacity parameter. Practical renderers truncate the footprint at a finite support threshold and may clamp opacity values for numerical stability. They also apply filtering or minimum-footprint adjustments to avoid unstable behavior when projected Gaussians become smaller than a pixel.

Overlapping primitives are combined by front-to-back alpha compositing. For primitives ordered from near to far, the rendered color is

C(p)=∑iTi(p) αi(p) ci(d)+Tend(p)Cbg,\mathbf{C}(\mathbf{p}) = \sum_i T_i(\mathbf{p})\, \alpha_i(\mathbf{p})\, \mathbf{c}_i(\mathbf{d}) + T_{\mathrm{end}}(\mathbf{p})\mathbf{C}_{\mathrm{bg}},

with

Ti(p)=∏j<i(1−αj(p)).T_i(\mathbf{p}) = \prod_{j<i}\left(1-\alpha_j(\mathbf{p})\right).

Here TiT_i is the remaining transmittance before primitive ii, and the last term accounts for a background that remains visible. Once transmittance becomes sufficiently small, farther primitives contribute negligibly and processing can stop.

This construction resembles discretized emission–absorption rendering, but standard splatting is not an exact integral through a physically defined Gaussian density field. Opacity is associated with the projected footprint, and visibility is approximated through a chosen ordering. The model is effective as an image-synthesis system because optimization can adjust its parameters to match photographs. That success does not imply that its opacity, depth, or color parameters directly correspond to independently measured physical properties.

GPU rasterization and visibility processing

The speed of 3D Gaussian splatting depends heavily on its rendering pipeline. Projecting every Gaussian and comparing it against every image pixel would be prohibitively expensive. Instead, the image is divided into small tiles, and each primitive is assigned only to the tiles intersected by its projected footprint. The original implementation used 16×1616\times16-pixel tiles. This limits most computations to local groups of potentially relevant primitives.

A typical pipeline first transforms and projects the Gaussians, rejects those outside the relevant viewing region, and estimates screen-space bounds. It then produces records identifying the tiles touched by each surviving primitive. A Gaussian covering several tiles appears in several records. These records are sorted so that each tile receives a depth-ordered list. The process is well suited to parallel computing, although sorting, temporary storage, and uneven workloads can become significant costs.

Within a tile, GPU threads process image pixels while sharing batches of Gaussian parameters. Each thread evaluates the Gaussian footprint at its pixel, computes opacity and color, and updates accumulated color and transmittance. Shared-memory reuse reduces repeated access to the same primitive data. Early termination avoids processing distant contributions after the pixel becomes effectively opaque. The original implementation used specialized CUDA kernels rather than relying solely on a conventional graphics shader pipeline.

Visibility ordering is a central approximation. A common renderer sorts by the depth of each Gaussian’s center, often within tile lists. This provides a single order for primitives that may overlap differently across individual pixels. Large or intersecting ellipsoids can violate that order, producing changes in appearance as the camera moves. More precise per-pixel ordering or alternative transparency methods can reduce such artifacts, but usually add computation or memory traffic.

Rendering cost depends on more than the total primitive count. Two scenes with one million Gaussians can have very different performance. Small, well-distributed footprints may be efficient, whereas large translucent footprints can overlap many tiles and cause extensive blending. Screen resolution, opacity distribution, background visibility, and camera position all influence the number of primitive–pixel interactions. For this reason, a reported frame rate is meaningful only alongside hardware, resolution, scene, and implementation details.

The rendering procedure is also designed for differentiable rendering. During training, a backward pass computes how changes in primitive parameters would change the rendered image. The original implementation avoids retaining a complete, explicit per-pixel history of every contribution, instead exploiting stored information and the compositing structure to recover the quantities needed for gradients. This makes the renderer both a display engine and a component of an optimization system.

Reconstruction from photographs and optimization

A standard reconstruction pipeline starts with multiple photographs of a mostly static scene. The images should overlap sufficiently for visual correspondences to be found, and their camera poses and internal calibration must be known or estimated. Structure from motion is commonly used to recover camera positions and orientations together with a sparse point cloud. Systems such as COLMAP provide this initialization through feature matching, triangulation, and bundle adjustment.

The sparse points serve as initial Gaussian centers. Their colors can initialize the direction-independent appearance terms, while distances to neighboring points provide a scale estimate. This initialization is useful because it places primitives near observed scene structure rather than distributing them arbitrarily through space. It is not a fundamental requirement: variants can start from random points, depth estimates, or other geometric inputs, although these choices change the difficulty of optimization.

Training repeatedly selects a camera, renders the current representation, and compares the result with the corresponding photograph. The original method combines an absolute image-difference term with a structural-similarity term:

L=(1−λ)L1+λ(1−SSIM⁡),\mathcal{L} = (1-\lambda)\mathcal{L}_1 + \lambda\left(1-\operatorname{SSIM}\right),

where SSIM measures local similarity in image structure, contrast, and luminance. The original configuration used λ=0.2\lambda=0.2. This loss function encourages both pixelwise agreement and preservation of local image patterns, although neither component directly enforces geometrically correct surfaces.

Gradients propagate from the image loss through color evaluation, compositing, projected footprints, and three-dimensional parameters. backpropagation and the Adam optimizer update positions, scales, rotations, opacity, and appearance. Different parameter groups can use different learning rates because they affect the image in different ways. The original training schedule progressively introduced higher-order spherical-harmonic coefficients, allowing the representation to establish simpler appearance before fitting more complex directional variation.

The resulting problem is nonconvex and underconstrained. An image mismatch may be explained by incorrect geometry, incorrect color, an inaccurate camera pose, or an unmodeled illumination change. A representation can therefore reproduce its input images while containing incorrect depths or extraneous primitives. Exposure differences, moving objects, motion blur, and calibration errors can all be absorbed into the learned representation rather than correctly identified as separate causes.

Evaluation consequently requires held-out views rather than only training-image reconstruction. The separation between training data and a test set matters because highly flexible Gaussian collections can fit the supplied photographs more closely than they predict genuinely new views. Baseline training typically optimizes a separate representation for each captured scene; it is not, by itself, a pretrained system that reconstructs arbitrary environments in a single forward pass.

Adaptive densification and primitive removal

A fixed set of initial Gaussians is rarely sufficient for detailed reconstruction. Sparse structure-from-motion points tend to concentrate on visually distinctive features and may omit smooth walls, thin objects, reflective regions, or distant details. The original method therefore changes the number and distribution of primitives during training. This process, called adaptive density control, is one of the main reasons it can turn a sparse initialization into a detailed image-based representation.

The principal signal for adding detail is the accumulated magnitude of gradients with respect to projected Gaussian positions. A large image-space positional gradient indicates that moving a primitive’s footprint could substantially reduce image error. This is a useful indicator of insufficient local representational capacity, although it is not a direct measurement of missing geometry. Gradients can also become large because of occlusion boundaries, erroneous poses, or inconsistent observations.

Two operations address different configurations. Cloning duplicates a relatively small Gaussian in a region needing additional capacity. The duplicates can subsequently move and specialize during optimization. Splitting replaces a large Gaussian with several smaller ones, distributing them according to the parent’s spatial extent and reducing their scales. Splitting allows broad primitives that initially cover coarse structure to give way to more localized elements.

Pruning counterbalances this growth. Gaussians with very low opacity can be removed because they contribute little to rendered images. Implementations may also remove primitives that become excessively large in image space or world space. In the original training procedure, periodic opacity resets reduced opacity values so that unnecessary primitives could become removable and poorly balanced opacity configurations could be reconsidered. These operations are optimization heuristics rather than consequences of a unique physical scene model.

The thresholds and schedule strongly influence the result. Aggressive densification can improve fine detail but increase memory consumption and rendering time. Conservative densification can leave blurred textures, incomplete structures, or oversized Gaussians. Pruning can remove artifacts, but may also erase weakly observed geometry. A detailed scene may require millions of primitives, while a simpler object can be represented with far fewer.

Later work has explored alternatives to the original gradient threshold, including criteria based on image residuals, estimated importance, geometric constraints, and explicit resource budgets. A recurring difficulty is that signed gradients from different pixels can cancel when aggregated, even when a primitive covers a region with substantial unresolved error. Different accumulation rules therefore lead to different growth behavior. Adaptive density control is best understood as joint optimization of representation complexity and image fit, not merely as adding points wherever a photograph contains high-frequency texture.

Image quality, sampling, and evaluation

Image quality in Gaussian splatting depends on both the fitted representation and the sampling properties of the renderer. A Gaussian footprint is smooth, but smooth primitives do not automatically eliminate aliasing. Problems arise when scene detail is optimized for one set of image resolutions and then rendered at another. Fine structures can flicker, appear too thick, or disappear, and image brightness can change when filtering does not preserve the appropriate integrated contribution.

The original renderer included image-space footprint enlargement to provide a minimum level of coverage. Such measures improve stability, but a fixed enlargement can blur small details and create scale-dependent behavior. Later methods, including Mip-Splatting, introduced more explicit treatment of sampling and filtering in three-dimensional and image spaces. Their objective is not simply sharper images, but more consistent appearance when the camera distance or output resolution changes.

Visibility produces another class of artifacts. Thin geometry may be represented by overlapping elongated Gaussians whose correct order changes across the image. A coarse ordering can then cause popping during camera motion. Unwanted primitives suspended away from the intended surfaces, commonly called floaters, may remain unobtrusive in training views but become conspicuous from new positions. These artifacts reflect the distinction between reproducing selected images and recovering a geometrically coherent scene.

Standard evaluations often report peak signal-to-noise ratio, SSIM, and learned perceptual distances such as LPIPS. Peak signal-to-noise ratio measures pixelwise error through mean squared differences; SSIM emphasizes local image structure; learned perceptual metrics compare features derived from neural networks. They capture different aspects of fidelity and need not rank methods identically. A high score on one metric does not establish accurate depth, reliable reflections, or stable behavior along a continuous camera path.

The original paper evaluated the method on scenes drawn from Mip-NeRF 360, Tanks and Temples, and Deep Blending. These collections include challenging indoor and outdoor imagery, but they do not cover every capture condition. Performance on sparse-view input, moving scenes, low-light photographs, transparent objects, or extreme extrapolation requires separate assessment. Comparisons also depend on image downsampling, cropping, exposure handling, and whether reconstruction inputs and evaluation protocols are identical.

A complete technical evaluation therefore includes rendering speed, training time, peak memory, model size, image fidelity, and temporal stability during viewpoint changes. Camera trajectories that remain close to the captured views test interpolation; trajectories that reveal unseen surfaces test a much harder problem. No image-based method can uniquely recover genuinely unobserved content without additional assumptions or learned prior information.

Storage, deployment, and scene interaction

The explicit representation makes Gaussian scenes comparatively straightforward to inspect and transform, but storing millions of primitives is expensive. Raw parameters can exceed the size of the original photograph collection, especially when high-order appearance coefficients are retained. Training checkpoints can be larger still because optimizer statistics and auxiliary state may be included. A compact rendered asset and a resumable training checkpoint are therefore different products with different storage requirements.

Compression methods exploit several forms of redundancy. Positions can be quantized relative to spatial regions; scales, rotations, and opacity can use reduced precision; similar colors or appearance coefficients can share codebooks. Higher-order spherical-harmonic coefficients can be reduced or omitted where their contribution is small. Data compression must nevertheless account for how parameter errors affect the final image: a small positional change near a silhouette can matter more than a larger change inside a uniform region.

Spatial organization is equally important for deployment. Large environments may be divided into blocks, with only nearby or visible portions loaded. Hierarchical representations can substitute coarser primitives for distant detail, reducing both memory traffic and projected overlap. Such level-of-detail systems must manage transitions carefully to avoid popping and must consider the combined opacity of overlapping primitives. Removing half the primitives does not generally preserve appearance unless their contributions are rebalanced.

Gaussian scenes can be displayed through native applications, game engines, and web browsers, but a fast research implementation does not automatically transfer to every platform. GPU memory limits, available compute interfaces, sorting efficiency, and mobile power budgets constrain practical performance. Stereo display for virtual reality adds requirements for low latency and consistent rendering between eyes. Rendering a single monoscopic frame interactively is therefore a less demanding target than a complete immersive application.

Editing is possible because primitives have explicit spatial parameters. A selected group can be translated, rotated, recolored, duplicated, or removed. However, visual objects are not automatically segmented into coherent collections, and learned appearance may contain shadows or reflections associated with the original surroundings. Moving an object’s Gaussians can leave behind missing background, baked-in shading, or inconsistent illumination.

The representation also lacks the connectivity and inside–outside definition normally expected by physics and geometry tools. Collision detection, watertight fabrication, conventional mesh texturing, and many engineering measurements require additional processing. Surface extraction can fit meshes to depths or to constrained Gaussian configurations, but converting a splat representation into a clean mesh is a reconstruction problem rather than a lossless file conversion.

Dynamic scenes, geometry-oriented variants, and semantic extensions

The original formulation assumes a static scene, but Gaussian primitives can be extended to represent motion. One approach assigns time-dependent positions, rotations, and scales to a persistent collection of Gaussians. Another learns a canonical scene together with a deformation field that maps its primitives into each animation frame. A third uses higher-dimensional Gaussian constructions that include time. These approaches trade off compactness, motion flexibility, and the ability to preserve correspondence between frames.

Dynamic reconstruction introduces ambiguities absent from static capture. A change in an image may result from camera motion, object motion, illumination, or occlusion. Monocular video is especially challenging because previously hidden regions may appear only briefly, and independently moving objects can violate assumptions used to estimate camera poses. Dynamic systems therefore often add temporal consistency, motion smoothness, or deformation constraints rather than fitting each frame independently.

Some variants target persistent tracking. If a Gaussian remains associated with the same local part of a moving object, its trajectory can provide a dense motion representation. Other approaches prioritize visual reconstruction and permit primitives to appear, disappear, or change identity. Good rendered video does not by itself demonstrate accurate physical tracking, so evaluation must distinguish image fidelity from correspondence quality.

Geometry-oriented variants modify the primitives or their constraints. In 2024, 2D Gaussian Splatting introduced planar Gaussian disks rather than unrestricted volumetric ellipsoids, together with rendering and regularization designed to support more consistent surface reconstruction. Related methods align Gaussian axes with estimated normals, constrain thickness, or encourage depth consistency. These changes address the fact that standard 3D Gaussians can fit photographs without converging to a unique surface.

Semantic extensions attach feature vectors or category information to primitives. Features derived from image models can be lifted into the reconstructed scene, enabling tasks such as text-based object selection, three-dimensional grouping, or semantic visualization. Links to semantic segmentation and language–image models such as CLIP make the representation more than a color renderer. Nevertheless, semantic features can be inconsistent across views, and object boundaries in feature space need not coincide with geometric boundaries.

Gaussian representations have also been incorporated into simultaneous localization and mapping. In this setting, camera tracking and map construction occur together, often under online computation constraints. Systems must decide when to add primitives, how to refine poses, and how to keep memory bounded. A visually convincing map can aid visualization, but reliable localization and metric mapping require additional checks on geometric consistency, loop closure, and long-term scene change.

Applications and unresolved limitations

The clearest application of 3D Gaussian splatting is interactive presentation of captured places and objects. Architectural interiors, outdoor locations, museum objects, film sets, and industrial facilities can be photographed and converted into navigable visual assets. Compared with a conventional textured model, the result can preserve complex appearance with less manual modeling. Compared with an image panorama, it supports translational viewpoint changes and associated parallax, within the limits of the captured coverage.

In cultural heritage and archaeology, such assets can support visual documentation and public interpretation. Their role must be distinguished from metrically validated survey data. A reconstruction optimized for photographic similarity can reproduce a carving or wall texture convincingly while placing some of its appearance at an incorrect depth. Measurement requires calibrated acquisition, scale control, geometric validation, and an explicit account of measurement uncertainty.

Media production uses Gaussian scenes for location visualization, virtual camera planning, and integration of captured environments into digital workflows. Robotics and simulation research can use them as visually rich backgrounds or as components of learned environment models. However, standard Gaussian assets do not supply the material parameters, collision geometry, or lighting response required for every simulation task. Their usefulness depends on whether the application primarily needs appearance or physically meaningful scene structure.

Relighting remains a major limitation of the basic formulation. Learned color and spherical-harmonic coefficients reproduce radiance under the illumination present during capture. They do not separately identify surface reflectance, light sources, and indirect illumination. A highlight may be encoded as a directional color pattern rather than generated by an explicit light interacting with a material. Changing the lighting therefore requires additional inverse-rendering models and constraints, particularly for cast shadows, glossy reflection, and interreflection.

Transparency, mirrors, and refractive objects are similarly difficult. A model may approximate their appearance over a narrow range of views, but standard compositing does not trace reflected or refracted paths through the environment. Sparse observations and wide viewpoint extrapolation expose these shortcomings. Coupling Gaussian representations with ray tracing, explicit materials, or learned view-synthesis components can address parts of the problem, but changes the computational model and may reduce the simplicity of the original renderer.

Capture and distribution also carry privacy implications. A reconstructed room, workplace, or street can retain legible documents, faces, screens, and spatial details from its source photographs. Removing a sensitive region from one rendered view does not necessarily remove the information from the underlying scene parameters. Reliable redaction requires identifying and modifying the relevant spatial content, then checking it from multiple viewpoints; the explicit representation makes such operations possible, but does not make them automatic.