---
kind: concept
slug: gaussian-splatting
title: Gaussian splatting
summary: >-
  2DGS gives surfaces. Splatter Image: one image. MVSplat: two views. FLARE: 2 to 8 uncalibrated views. iLRM: posed views. SparseGS, FSGS: 3 to 12 photos. PhysDreamer: forces. Reduced-3DGS compresses. Hierarchical 3DGS: large scenes. GSGEN: text to 3D. SLAM: SplaTAM, GS3LAM. Gaussian Grouping, Feature 3DGS: labels. SparseGrasp grasps. Driving: DriveSplat. Forge4D: human video. GEM-Occ: occupancy.
tags: [3d-reconstruction, novel-view-synthesis, differentiable-rendering, single-view-reconstruction, sparse-views, physics-simulation, compression, slam, segmentation, scene-editing, feature-distillation, grasping, autonomous-driving, relighting, dynamic-scenes, simulation, 4d-reconstruction, text-to-3d, level-of-detail, large-scenes, occupancy-mapping, camera-pose-estimation, feed-forward-3d]
papers: ["2403.17888", "2312.13150", "2312.00206", "2404.13026", "2406.17074", "2312.02126", "2603.27781", "2312.00732", "2312.03203", "2412.02140", "2508.15376", "2510.12308", "2602.13549", "2603.07552", "2605.08713", "2401.03890", "2403.14627", "2312.00451", "2509.24209", "2309.16585", "2406.12080", "2607.05543", "2502.12138", "2507.23277"]
related: [neural-radiance-field, neural-implicit-surface, multi-view-reconstruction, multi-view-stereo, cost-volume, novel-view-synthesis, feed-forward-reconstruction, few-shot-learning, monocular-depth-estimation, differentiable-simulation, material-point-method, diffusion-models, simultaneous-localization-and-mapping, semantic-segmentation, promptable-segmentation, open-vocabulary-segmentation, robotic-grasp-generation, knowledge-distillation, vector-quantization, network-pruning, low-precision-arithmetic, dynamic-neural-radiance-field, physically-based-rendering, sim-to-real-transfer, surface-normal-estimation, low-rank-adaptation, optical-flow, score-distillation-sampling, level-of-detail-rendering, camera-pose-encoding, attention-mechanism]
status: draft
updated_at: 2026-11-01
---

## Overview

Gaussian splatting fits a scene to posed photographs with a set of Gaussian
primitives, each with a position, shape, opacity and colour. The primitives
are drawn onto the image plane in depth order and blended front to back.
Training adjusts the primitives until the rendered images match the inputs
[arxiv:2403.17888 §3] [arxiv:2403.17888 §5].

The reference point is 3D Gaussian Splatting
([arXiv:2308.04079](https://arxiv.org/abs/2308.04079)). It uses volumetric 3D
Gaussians and an affine, locally linear approximation of the camera
projection. The 2DGS paper reports that this gives fast, high-quality images
but no native surface, so meshes taken from it are noisy
[arxiv:2403.17888 §3]. No card for that paper is in this repository yet, so
the account above is the 2DGS paper's description of it.

A 2024 survey card groups the follow-up work into eight directions: sparse
input, memory, photorealism, optimisation, extra properties, hybrid
representations, rendering and kernels [arxiv:2401.03890 §4] [arxiv:2401.03890 tab. S1].
The survey adds no new method. Its benchmark numbers are copied from the
original papers, so read those for values [arxiv:2401.03890 §6].

The idea most variants share is a depth-sorted, alpha-blended sum over
primitives, trained with a photometric loss against the input images, often
with further losses added [arxiv:2403.17888 §5].

Feed-forward variants skip the per-scene fit. A network reads the input
image(s) and outputs the primitives directly, so one pass replaces the
optimisation loop [arxiv:2312.13150 §3.2]. Two-view variants can place depth by matching
features across the views, rather than reading depth from one image
[arxiv:2403.14627 §1]. Some feed-forward variants also estimate the camera
poses from uncalibrated images [arxiv:2502.12138 §3.1], while another takes
poses and intrinsics as inputs [arxiv:2507.23277 §3.2].

Sparse-view variants keep the per-scene fit but add priors. With few photos the
plain fit produces floaters and background collapse at unseen viewpoints
[arxiv:2312.00206 §1]. FSGS instead grows the Gaussian set where neighbours are
far apart, and uses a depth prior without a diffusion model
[arxiv:2312.00451 §3.2] [arxiv:2312.00451 §3.3].

Physics-based variants keep the Gaussians as simulation particles and add an
elastic material model and a simulator, so the object can be pushed to move in
ways it has not been seen to move [arxiv:2404.13026 §4].

Dynamic feed-forward variants predict a Gaussian set for each frame and a
motion field between neighbouring frames. New times are then shown by moving
the Gaussians, with no fit per scene [arxiv:2509.24209 §3.4].

Compression variants keep the renderer and reduce the stored scene. They
prune primitives, drop unneeded colour terms and quantise the rest
[arxiv:2406.17074 §4].

SLAM variants fit the same kind of map online from RGB-D frames. Each frame is
tracked against the map, then new primitives are added and the map is refined
[arxiv:2312.02126 §3]. GS3LAM also attaches an extra per-primitive feature, a
semantic code, that is blended like colour [arxiv:2603.27781 §3.2].

Labelling variants keep the same renderer and blend a learned vector per
primitive with the same weights as colour. The vector is either a per-object
identity code supervised by 2D masks [arxiv:2312.00732 §3.2], or a distilled
feature from a 2D foundation model that supports text and point queries
[arxiv:2312.03203 §3.1] [arxiv:2312.03203 §3.2].

Robot-grasping variants use the splat as the scene that a grasp model reads.
They fit it from a few RGB views, distil a language-aligned feature into each
primitive, and update only the moved objects when the scene changes
[arxiv:2412.02140 §3.2] [arxiv:2412.02140 §3.3].

Driving-scene variants rebuild logged street footage so that views the car did
not drive can be rendered. They add tracked actors, a lighting model or
feed-forward inference on top of a splat renderer [arxiv:2508.15376 §3.3]
[arxiv:2602.13549 §3.2] [arxiv:2603.07552 §3.2]. Refinement variants keep a
Gaussian render and clean it with a diffusion model afterwards
[arxiv:2510.12308 §3.2]. One paper uses a scanned Gaussian scene only as the
simulator in which a parking policy is trained [arxiv:2605.08713 §5.1].

Generative variants start from a text prompt rather than photographs. GSGEN
initialises Gaussians from a text-to-point-cloud model, then optimises them
against a 2D image prior, with an added 3D prior on the geometry
[arxiv:2309.16585 §4.1] [arxiv:2309.16585 §4.3]. It reports no metric, only
visual comparisons [arxiv:2309.16585 §5.2].

Large-scene variants keep the renderer and add a hierarchy. Gaussians are
merged into parent nodes, and each view draws a cut through the tree at a
chosen pixel size [arxiv:2406.12080 §4.1] [arxiv:2406.12080 §4.2]. The
capture is split into chunks that are trained separately and then combined
[arxiv:2406.12080 §6].

Occupancy-memory variants do not render colour. They store occupied space as
Gaussians with log-odds, record visible free space as evidence, and fuse each
new posed frame into a persistent memory [arxiv:2607.05543 §3.1]
[arxiv:2607.05543 §3.2].

## Variants

### 3D Gaussian Splatting (reference)

Volumetric Gaussians rendered with an affine projection. It is the baseline
in every comparison in the 2DGS paper [arxiv:2403.17888 tab. 1]. No card yet,
so no figures from it are used on this page.

### 2D Gaussian Splatting (2DGS)

Card: [2D Gaussian Splatting for Geometrically Accurate Radiance Fields](/papers/2403.17888).

- **Primitive.** Each splat is a flat, oriented disk with a centre, two
  orthogonal tangent vectors and two scales. The normal is the cross product
  of the tangents, so every primitive has a well-defined surface normal
  [arxiv:2403.17888 §4.1].
- **Rendering.** Each pixel ray is intersected with the splat's plane in
  closed form, which avoids inverting the projection. A screen-space low-pass
  term keeps splats seen edge-on from disappearing
  [arxiv:2403.17888 §4.2].
- **Regularisers.** A depth-distortion loss pulls the splats along each ray
  together. A normal-consistency loss aligns each splat's normal with the
  normal of the rendered depth map [arxiv:2403.17888 §5].
- **Mesh.** Rendered median depth is fused into a mesh with TSDF fusion
  [arxiv:2403.17888 §6.1].
- **Reported results (author-reported).** On DTU, mean Chamfer distance 0.80
  after 30k iterations, against 1.96 for 3DGS, at 10.9 minutes per scene on
  one RTX 3090 [arxiv:2403.17888 tab. 1]. On Mip-NeRF 360, outdoor PSNR is 24.34
  against 24.64 for 3DGS [arxiv:2403.17888 tab. 4].

### Feed-forward prediction (Splatter Image)

Card: [Splatter Image: Ultra-Fast Single-View 3D Reconstruction](/papers/2312.13150).

- **Predictor.** A 2D U-Net maps one image to one Gaussian per pixel, so the
  output is an image-shaped grid of primitives. Each Gaussian sits on its
  pixel's camera ray at a predicted depth, moved by a predicted 3D offset
  [arxiv:2312.13150 §3.2] [arxiv:2312.13150 eq. 3].
- **Training.** The predicted Gaussians are rendered at other camera poses and
  compared with the real target views by squared error. A perceptual LPIPS
  term is added in a second stage [arxiv:2312.13150 §3.3]
  [arxiv:2312.13150 app. C].
- **Several views.** Each view's Gaussians are moved into a common frame with
  the relative pose and merged by taking their union. Cross-view attention is
  applied at the lowest U-Net resolution [arxiv:2312.13150 §3.4]
  [arxiv:2312.13150 §3.6].
- **Scope.** Object-centric reconstruction with relative camera poses only,
  not generalisation to unseen scenes [arxiv:2312.13150 §2]
  [arxiv:2312.13150 app. B].
- **Reported results (author-reported).** Single view, ShapeNet-SRN cars:
  PSNR 24.00, the highest value in the paper's table [arxiv:2312.13150 tab. 1].
  On Google Scanned Objects, PSNR 21.06 against 18.06 for OpenLRM
  [arxiv:2312.13150 tab. 4]. Rendering 250 views at 128 × 128 takes 0.451 s on
  one V100 for one input view [arxiv:2312.13150 tab. 7].

### Two-view feed-forward with a cost volume (MVSplat)

Card: [MVSplat: Efficient 3D Gaussian Splatting from Sparse Multi-View Images](/papers/2403.14627).

Takes posed images and outputs one Gaussian per pixel per view in one pass.
Depth comes from matching features across views on a set of depth planes
[arxiv:2403.14627 §3.1].

- **Matching.** The other view's features are warped onto 128 depth planes,
  spaced evenly in inverse depth, and compared with the reference view by a
  scaled dot product. A U-Net refines the cost volume, and a softmax over the
  planes gives the coarse depth as an expectation [arxiv:2403.14627 §3.1]
  [arxiv:2403.14627 eq. 3] [arxiv:2403.14627 eq. 6].
- **Depth refinement.** A second, light U-Net predicts a residual depth from the
  images, features, coarse depth and matching confidence
  [arxiv:2403.14627 §3.1] [arxiv:2403.14627 app. C].
- **Gaussians.** Each pixel's depth is unprojected along its ray to give the
  Gaussian centre. Opacity, covariance and colour come from heads on the
  refined output [arxiv:2403.14627 §3.2].
- **Training.** Only rendering losses on target views: an L2 term and an LPIPS
  term at weight 0.05. No depth supervision [arxiv:2403.14627 §3.3].
- **Reported results (author-reported).** RealEstate10K, two context views,
  256 × 256: PSNR 26.39 and LPIPS 0.128, against 25.89 and 0.142 for pixelSplat
  [arxiv:2403.14627 tab. 1]. Time per scene is 0.044 s against 0.104 s, and
  parameters 12.0 M against 125.4 M. The timing hardware is not stated
  [arxiv:2403.14627 tab. 1]. Trained on RealEstate10K only, DTU PSNR is 13.94
  against 12.89 for pixelSplat [arxiv:2403.14627 tab. 2].
- **Ablation.** Without the cost volume, PSNR falls to 22.83 from 26.39
  [arxiv:2403.14627 tab. 3].
- **Scope.** Needs known intrinsics and extrinsics, and a near and far depth
  range for each view [arxiv:2403.14627 §3] [arxiv:2403.14627 app. C]. It
  evaluates with two context views, and the model accepts more at test time
  [arxiv:2403.14627 §4.2]. The paper says reflective surfaces such as glass
  and windows are unreliable [arxiv:2403.14627 §5].

### Pose-first feed-forward from uncalibrated views (FLARE)

Card: [FLARE: Feed-forward Geometry, Appearance and Camera Estimation from Uncalibrated Sparse Views](/papers/2502.12138).

Estimates the camera poses as well as the scene, from uncalibrated images, and
then regresses Gaussians in the same forward pass. Built for two to eight views
[arxiv:2502.12138 §1].

- **Pipeline.** A pose predictor runs first. A second transformer predicts
  camera-centric point maps and refines the poses. A third maps the local points
  into one global frame, and a fourth regresses the Gaussians, whose centres are
  the global points [arxiv:2502.12138 §3.1] [arxiv:2502.12138 §3.2]
  [arxiv:2502.12138 §3.3].
- **Appearance.** A DPT head gives an appearance feature. It is fused with VGG
  features of the input images, and a shallow CNN predicts opacity, rotation,
  scale and spherical-harmonic colour [arxiv:2502.12138 §3.3].
- **Training.** A pose loss, a confidence-weighted geometry loss and a splatting
  loss. The splatting loss is an L2 term, plus 0.5 times a VGG perceptual term
  and 0.1 times a depth term [arxiv:2502.12138 §3.4]. The weights of the pose and
  geometry losses are not stated [arxiv:2502.12138 §3.4].
- **Reported results (author-reported).** RealEstate10K, five inputs, no
  fine-tuning: AUC@30° 79.9, against 61.1 for MASt3R and 51.6 for PoseDiffusion
  [arxiv:2502.12138 tab. 1]. On DL3DV, eight input views give PSNR 23.33,
  against 22.08 for MVSplat with its two closest views. The inputs differ, so
  the comparison is not matched [arxiv:2502.12138 tab. 3] [arxiv:2502.12138 §4.3].
- **Cost.** About 14 days on 64 GPUs for 200 epochs [arxiv:2502.12138 §4]. The
  hardware behind the under-0.5 s inference claim is not stated
  [arxiv:2502.12138 §1].
- **Scope.** Trained with eight views per sample. The paper says the number of
  views is limited only by GPU memory, but its evidence beyond eight is one DTU
  table with up to 25 views [arxiv:2502.12138 §3.2] [arxiv:2502.12138 tab. 6].
  The RealEstate10K novel-view model is fine-tuned with intrinsics as a condition
  [arxiv:2502.12138 §4.3].
- **Scale at test time.** Predicted and ground-truth scale factors normalise the
  Gaussians and the novel camera. The paper does not say how the ground-truth
  factor is obtained for unseen scenes [arxiv:2502.12138 §3.3]
  [arxiv:2502.12138 eq. 6].

### Iterative feed-forward with viewpoint tokens (iLRM)

Card: [iLRM: An Iterative Large 3D Reconstruction Model](/papers/2507.23277).

Takes posed images and outputs Gaussians in one pass. It keeps viewpoint tokens,
one per image patch, and refines them over several layers, each layer reading
the image tokens of its own view [arxiv:2507.23277 §1] [arxiv:2507.23277 §3.2].

- **Inputs.** Plücker rays, built from the intrinsics and poses, are the only
  source of viewpoint tokens, with no learned queries. Image tokens combine RGB
  and rays [arxiv:2507.23277 §3.2] [arxiv:2507.23277 eq. 2].
- **Update layers.** Twelve layers. Each has a cross-attention in which a
  viewpoint token attends only to the image tokens of its own view, then a
  self-attention over the viewpoint tokens of all views
  [arxiv:2507.23277 §3.2] [arxiv:2507.23277 eq. 3] [arxiv:2507.23277 eq. 4].
- **Output.** One linear layer maps each token to Gaussian parameters. Colour is
  degree-0 only [arxiv:2507.23277 §3.2] [arxiv:2507.23277 app. A].
- **Training.** Gaussians are rendered into held-out target views and compared
  with MSE plus a perceptual term, weighted by 0.5 [arxiv:2507.23277 §3.3]
  [arxiv:2507.23277 eq. 5].
- **Reported results (author-reported).** RealEstate10K, two views at 256 × 256:
  PSNR 28.65 against 27.47 for DepthSplat, and 0.025 s against 0.065 s per scene
  on an RTX 4090 [arxiv:2507.23277 tab. 1]. With 32 views at 540 × 960, PSNR is
  24.30 in 0.53 s, against 24.43 for 3D-GS at 8 minutes [arxiv:2507.23277 tab. 5].
- **Ablation.** Without iterative refinement, PSNR on the four-view setting falls
  to 28.58 from 29.24 [arxiv:2507.23277 tab. 7]. The ablations use a different
  training setup from the main table.
- **Scope.** The released code implements only the two-view, full-resolution
  setting. Token uplifting and mini-batch cross-attention from the paper are not
  in it, so the paper's efficiency argument does not hold for that code (see the
  iLRM card's Paper vs code section) [arxiv:2507.23277 §3.2]
  [arxiv:2507.23277 fig. 4].
- **Pose sensitivity.** Under translation noise, PSNR falls from 24.30 to 21.49
  at σ = 0.005, against 23.97 to 20.49 for Long-LRM [arxiv:2507.23277 app. F].

### Sparse views (SparseGS)

Card: [SparseGS: Sparse View Synthesis using 3D Gaussian Splatting](/papers/2312.00206).

Keeps the 3DGS fit and adds three training signals and a pruning step. Built
for 12 input views on 360-degree scenes and 3 on forward-facing scenes
[arxiv:2312.00206 §1].

- **Depth prior.** A pre-trained monocular depth model gives pseudo-depth for
  each training view. The softmax-scaled depth of the Gaussians is compared with
  it by one minus the Pearson correlation, on random patches and globally. The
  correlation ignores scale and shift [arxiv:2312.00206 §3.2] [arxiv:2312.00206 eq. 8].
- **Unseen views.** Score distillation with Stable Diffusion 2.1 on random
  cameras around the training cameras, plus an L1 loss on training views warped
  to nearby poses [arxiv:2312.00206 §3.3.1] [arxiv:2312.00206 §3.3.2]. The
  distillation term starts after two-thirds of the iterations [arxiv:2312.00206 §4.1].
- **Floater pruning.** After fitting, pixels whose mode-selected and
  alpha-blended depths disagree strongly are flagged, and the Gaussians on their
  rays up to the mode are deleted [arxiv:2312.00206 §3.4] [arxiv:2312.00206 app. C].
- **Reported results (author-reported).** Mip-NeRF 360, 12 views: PSNR 19.37,
  against 17.49 for 3DGS and 19.31 for FSGS [arxiv:2312.00206 tab. 1]. LLFF PSNR
  19.86 against 16.94 for 3DGS [arxiv:2312.00206 tab. 2]. On DTU the method is
  level with DNGaussian: PSNR 18.89 against 18.91 [arxiv:2312.00206 tab. 2].
- **Cost.** The paper gives no hardware or training time [arxiv:2312.00206 §4.1].

### Sparse views without diffusion (FSGS)

Card: [FSGS: Real-Time Few-shot View Synthesis using Gaussian Splatting](/papers/2312.00451).

Keeps the 3DGS renderer. The Gaussian set grows where it is sparse, and a
depth prior regularises training and synthesised views. Built for three
training views on LLFF and Shiny, and eight on Blender [arxiv:2312.00451 §4.1].

- **Growth.** Each Gaussian links to its three nearest neighbours. Where its
  mean distance to them is above a threshold, one new Gaussian is placed at the
  midpoint of each link [arxiv:2312.00451 §3.2] [arxiv:2312.00451 eq. 4]. The
  threshold is 10, given without units, so it depends on each scene's scale
  [arxiv:2312.00451 §4.1].
- **Pseudo views.** From iteration 2,000, a camera is made from two training
  cameras by averaging their rotations and locations, with noise added to the
  location [arxiv:2312.00451 §3.3] [arxiv:2312.00451 eq. 5] [arxiv:2312.00451 §4.1].
- **Depth term.** A pretrained monocular depth model predicts a depth map for
  each training image and each rendered pseudo view. The rendered depth is
  compared with it by the Pearson correlation, which ignores the prior's
  unknown scale [arxiv:2312.00451 §3.3] [arxiv:2312.00451 eq. 6]. As printed,
  the weighted term in eq. 8 is minimised at zero correlation, which conflicts
  with the stated aim, so the sign has to be chosen when implementing
  [arxiv:2312.00451 eq. 8].
- **Weights.** L1 0.8, D-SSIM 0.2 and depth 0.05, found by grid search
  [arxiv:2312.00451 §3.4]. The weight for the pseudo-view term is not given
  [arxiv:2312.00451 alg. 1].
- **Reported results (author-reported).** LLFF, three views, 1/8 resolution:
  PSNR 20.31 at 458 FPS, against 19.86 at 0.21 FPS for SparseNeRF
  [arxiv:2312.00451 tab. 1]. On LLFF the unpooling step alone gives 18.64,
  depth regularisation 19.83 and pseudo views 20.31 [arxiv:2312.00451 tab. 4].
- **Cost.** About 9.5 minutes on LLFF and 24 minutes on Mip-NeRF 360, on one
  A6000 [arxiv:2312.00451 §4.1]. After iteration 2,000 each step also runs the
  depth model on a rendered pseudo view [arxiv:2312.00451 alg. 1].
- **Scope.** Mip-NeRF 360 uses 24 training views and is not a few-shot test
  [arxiv:2312.00451 §4.1]. The depth model is named two ways (see
  Contradictions).

### Physics-based interaction (PhysDreamer)

Card: [PhysDreamer: Physics-Based Interaction with 3D Objects via Video Generation](/papers/2404.13026).

Starts from a static Gaussian object and estimates how stiff each part is.
The material is then used in a simulator, so new forces give new motion.

- **Reference motion.** The static scene is rendered from one viewpoint and
  animated by a video diffusion model into 14 frames. That clip is the
  training target [arxiv:2404.13026 §4] [arxiv:2404.13026 §5.2].
- **Material.** Each Gaussian is a simulation particle in a fixed corotated
  elastic model. Young's modulus is a per-particle field, predicted by a
  triplane and an MLP. Poisson's ratio is one constant [arxiv:2404.13026 §4.1]
  [arxiv:2404.13026 §4.2] [arxiv:2404.13026 §3].
- **Fit.** Two stages. The first fits an initial velocity field on the first
  three frames. The second fits the modulus with the velocity frozen. The loss
  compares rendered and reference frames [arxiv:2404.13026 §4.2]
  [arxiv:2404.13026 eq. 10].
- **Speed-up.** The simulation runs on K-Means driving particles. Each Gaussian
  is moved by a rigid transform fitted to its 8 nearest driving particles
  [arxiv:2404.13026 §4.3] [arxiv:2404.13026 alg. 1].
- **Interaction.** After fitting, a new force or initial velocity is applied,
  the scene is simulated and rendered from any viewpoint [arxiv:2404.13026 §5.1]
  [arxiv:2404.13026 fig. 5].
- **Reported results (author-reported).** In a 2AFC study by 100 participants
  on eight real scenes, 80.8% preferred it over PhysGaussian for motion
  realism, and 63.5% preferred it over DreamGaussian4D [arxiv:2404.13026 tab. 1].
  The study measures perceived realism, not physical accuracy
  [arxiv:2404.13026 §5.1]. Compute is about one minute on one V100 per second
  of generated video [arxiv:2404.13026 §6].
- **Limits.** Elastic materials only, no collisions. The object is separated
  from the background and stationary parts are fixed by hand
  [arxiv:2404.13026 §6].

### Compression (Reduced-3DGS)

Card: [Reducing the Memory Footprint of 3D Gaussian Splatting](/papers/2406.17074).

Keeps the 3DGS renderer and shrinks what is stored. Three steps run in order.

- **Pruning.** Every 1000 iterations, a Gaussian is redundant when many others
  fall in a sphere around it. Half of the redundant ones, the lower-opacity
  half, are deleted. The lowest 3% by opacity are also deleted, capped at
  opacity 0.05 [arxiv:2406.17074 §4.1].
- **Colour bands.** At iteration 15,000, each Gaussian keeps 0 to 3
  spherical-harmonic bands, chosen by how much its colour changes with the
  viewing angle. The reported split for the main model is 89%, 0.1%, 2.7% and
  8.2% of primitives at 0, 1, 2 and 3 bands [arxiv:2406.17074 §4.2].
- **Quantisation.** After training, most attributes are clustered into 256-entry
  k-means codebooks and stored as one-byte indices. Positions and codebook
  entries are stored as 16-bit floats [arxiv:2406.17074 §4.3].
- **Reported results (author-reported).** Sizes on disk fall from 412 to 744 MB
  for the authors' 3DGS re-run to 14 to 29 MB, with PSNR changes between
  −0.32 and +0.16 dB [arxiv:2406.17074 tab. 1]. Rendering is 1.6 to 1.9 times
  faster per scene, about 1.7 times on average [arxiv:2406.17074 tab. 2]. The
  authors keep 43% of the baseline primitives [arxiv:2406.17074 tab. 3].
- **Memory during training.** The authors say the peak training memory is
  unchanged, so the saving is on disk and at render time
  [arxiv:2406.17074 §5].

### Dense RGB-D SLAM (SplaTAM)

Card: [SplaTAM: Splat, Track & Map 3D Gaussians for Dense RGB-D SLAM](/papers/2312.02126).

Keeps a map of Gaussians without a semantic channel. Each frame is tracked
with the map fixed, densified where the map is empty or misses depth, and
then the map is refined on keyframes [arxiv:2312.02126 §3].

- **Scene model.** Each Gaussian has a colour, a centre, a radius and an
  opacity. Colour is view-independent and the Gaussians are isotropic
  [arxiv:2312.02126 §3].
- **Tracking.** The pose starts from a constant-velocity guess. It is then
  optimised with the Gaussians fixed, on pixels whose silhouette is above 0.99.
  Depth error counts with weight 1.0 and colour error with 0.5
  [arxiv:2312.02126 §3] [arxiv:2312.02126 eq. 8].
- **Densification.** A pixel is densified when the silhouette is below 0.5, or
  when the ground-truth depth lies in front of the rendered depth by more than
  50 times the median depth error [arxiv:2312.02126 eq. 9].
- **Mapping.** Poses are fixed and all Gaussians are refined on the current
  frame and on keyframes that overlap it. Every n-th frame becomes a keyframe
  [arxiv:2312.02126 §3].
- **Reported results (author-reported).** Replica tracking error averages
  0.36 cm, against 0.52 cm for Point-SLAM [arxiv:2312.02126 tab. 1]. On ScanNet++
  it reports 1.2 cm where Point-SLAM is at 343.8 cm and ORB-SLAM3 at 158.2 cm
  [arxiv:2312.02126 tab. 1]. Replica training-view PSNR is 34.11 dB against
  35.17 dB for Point-SLAM, which uses ground-truth depth to sample its map
  [arxiv:2312.02126 tab. 2].
- **Cost.** On Replica R0 the full model takes 1.00 s to track and 1.44 s to map
  per frame. SplaTAM-S takes 0.19 s and 0.33 s [arxiv:2312.02126 tab. 6]. Neither
  runs in real time.
- **Limits.** The method needs known intrinsics and dense depth. It is sensitive
  to motion blur, large depth noise and fast rotation [arxiv:2312.02126 §5].

### Semantic SLAM (GS3LAM)

Card: [GS3LAM: Gaussian Semantic Splatting SLAM](/papers/2603.27781).

Builds a map from RGB-D frames while estimating the camera pose. Each Gaussian
carries a semantic feature that a learned layer turns into class scores.

- **Scene model.** Each Gaussian has a colour, depth and a low-dimensional
  semantic feature. The features are alpha-blended like colour, then decoded
  with a softmax [arxiv:2603.27781 §3.2] [arxiv:2603.27781 eq. 8].
- **Tracking.** Each new frame is aligned by optimising only the camera pose
  against photometric, depth and semantic error on the region the map already
  observes. The map is frozen during this step [arxiv:2603.27781 §3.4].
- **Expansion.** After tracking, new Gaussians are added only where the map
  does not yet explain the frame, so the count stays down where the map is
  already complete [arxiv:2603.27781 §3.3.1] [arxiv:2603.27781 §3.3.2].
- **Mapping.** The map is refined on the current frame and on keyframes drawn
  at random, which the paper offers as a replacement for the keyframe selection
  in SplaTAM and Point-SLAM [arxiv:2603.27781 §3.3.3].
- **Scale regulariser.** A penalty pushes Gaussian scales away from the
  extremes. The paper presents it as a contribution, and its Replica config
  turns it off (see the card's Paper vs code section)
  [arxiv:2603.27781 §3.3.2] [arxiv:2603.27781 eq. 12].
- **Inputs.** RGB-D frames with unknown poses and one semantic label map per
  frame, from the dataset or a segmentation model [arxiv:2603.27781 §3.1]
  [arxiv:2603.27781 §3.3.4].
- **Reported results (author-reported).** On Replica, rendering PSNR 36.26
  over eight scenes against 34.11 for SplaTAM [arxiv:2603.27781 tab. 2].
  Semantic mIoU 96.63 over four scenes against 87.41 for SNI-SLAM
  [arxiv:2603.27781 tab. 4]. Tracking ATE 0.37 cm against 0.36 cm for SplaTAM
  [arxiv:2603.27781 tab. 3]. Rendering runs at 109 FPS on average
  [arxiv:2603.27781 app. C.2].

### Object segmentation and editing (Gaussian Grouping)

Card: [Gaussian Grouping: Segment and Edit Anything in 3D Scenes](/papers/2312.00732).

Adds a 16-dimensional identity encoding to each Gaussian of a 3DGS scene.
The encodings are trained from SAM masks that are tracked across views, so
each object gets one ID. No 3D labels are needed [arxiv:2312.00732 §3].

- **Supervision.** SAM runs in everything mode on each view. DEVA links the
  masks across views and gives the number of identities K. A linear layer maps
  the rendered encoding to K logits, trained with cross-entropy against the
  mask IDs [arxiv:2312.00732 §3.2 (a)–(d)] [arxiv:2312.00732 eq. 4].
- **3D consistency.** A KL term compares each sampled Gaussian's class
  distribution with those of its 5 nearest Gaussians in 3D. The authors
  motivate it with Gaussians that get little 2D supervision
  [arxiv:2312.00732 §3.2 (d)] [arxiv:2312.00732 §4.2].
- **Editing.** Removal, recomposition and colour changes act on groups without
  tuning. Inpainting and style transfer fine-tune only the affected Gaussians
  [arxiv:2312.00732 §3.3].
- **Reported results (author-reported).** LERF-Mask figurines mIoU 69.7
  against 33.5 for LERF [arxiv:2312.00732 tab. 3]. On Mip-NeRF 360 the PSNR is
  28.43 against 28.69 for 3DGS [arxiv:2312.00732 tab. 1]. Training is 30K
  iterations in the paper [arxiv:2312.00732 §4.1.2].
- **Limits.** Static scenes only [arxiv:2312.00732 §4.4]. Groups are anonymous
  IDs, so text queries need an extra detector to pick a mask
  [arxiv:2312.00732 §4.3]. Inpainting needs several extra models per view
  [arxiv:2312.00732 app. 3D Object Inpainting Pipeline].

### Language feature field (Feature 3DGS)

Card: [Feature 3DGS: Supercharging 3D Gaussian Splatting to Enable Distilled Feature Fields](/papers/2312.03203).

Adds an N-channel feature to each Gaussian and distils it from a 2D teacher
(LSeg or SAM) through the same differentiable splatting that renders colour
[arxiv:2312.03203 §3.1].

- **Joint rasterisation.** Colour and feature go through one rasteriser with
  different channel counts. This avoids the quality loss of rendering them in
  two stages [arxiv:2312.03203 §3.1].
- **Speed-up.** The feature is drawn with N smaller than the teacher's M
  channels, then a 1×1 convolution lifts it to M. The paper uses N = 128 on
  Replica [arxiv:2312.03203 §3.2] [arxiv:2312.03203 app. F].
- **Queries.** A text or label feature is compared with each Gaussian by cosine
  similarity, then a softmax gives a probability. Thresholds select Gaussians
  for extraction, deletion or appearance changes [arxiv:2312.03203 §3.3]
  [arxiv:2312.03203 eq. 5] [arxiv:2312.03203 eq. 6].
- **Reported results (author-reported).** On Replica, mIoU 0.782 at N = 128
  with 14.55 FPS, against 0.636 mIoU and 5.38 FPS for NeRF-DFF
  [arxiv:2312.03203 tab. 2]. Replica PSNR 37.01 against 36.13 for base 3DGS
  [arxiv:2312.03203 tab. 1].
- **Cost.** Training time grows steeply with N. At N = 128 it is 19:55 and at
  N = 512 it is 1:29:42 on the Replica LSeg setup [arxiv:2312.03203 tab. A].
- **Limits.** The teacher features are precomputed per view and are large
  [arxiv:2312.03203 Pitfalls]. The edit threshold is not stated in the paper
  and is tuned per scene [arxiv:2312.03203 §3.3].

### Grasping in changing scenes (SparseGrasp)

Card: [SparseGrasp: Robotic Grasping via 3D Semantic Gaussian Splatting from Sparse Multi-View RGB Images](/papers/2412.02140).

Fits a 3DGS scene to three RGB views and distils PCA-compressed MaskCLIP region
features into it. A grasp model is then trained to read the Gaussians directly
[arxiv:2412.02140 §3.1] [arxiv:2412.02140 §3.2] [arxiv:2412.02140 §3.4].

- **Initialisation.** DUSt3R, given calibrated poses, gives a dense point cloud
  resampled to about 100,000 points. The paper argues that sparse COLMAP points
  overfit with few views [arxiv:2412.02140 §3.1] [arxiv:2412.02140 §4]
  [arxiv:2412.02140 fig. 3].
- **Semantic features.** One feature is averaged per mask, then reduced to 16
  dimensions with PCA. The rendered features are trained against these targets
  with an L1 loss [arxiv:2412.02140 §3.1] [arxiv:2412.02140 §3.2]
  [arxiv:2412.02140 eq. 5].
- **Scene update.** Changed pixels are found with MOG2 background subtraction.
  Gaussians matched to the moved pixels by cosine similarity have only their
  translation and rotation optimised [arxiv:2412.02140 §3.3]
  [arxiv:2412.02140 eq. 6].
- **Grasping.** GraspNet is retrained to take each Gaussian's centre, scale and
  rotation instead of a point cloud [arxiv:2412.02140 §3.4]
  [arxiv:2412.02140 fig. 4].
- **Reported results (author-reported).** Static grasping with three views
  succeeds 55 times in 70 trials. F3RM with 17 views succeeds 38 times, and with
  three views 4 times [arxiv:2412.02140 tab. 1]. Scene update at a 200 ms budget
  succeeds 22 times in 25, against 20 for F3RM after a 10-minute re-scan
  [arxiv:2412.02140 tab. 2]. Reconstruction takes about 4 minutes, against 10
  for F3RM [arxiv:2412.02140 tab. 4].
- **Limits.** Adding or removing objects needs a scene refresh
  [arxiv:2412.02140 §4.3]. Update success depends on the budget: the paper's
  per-scene entries sum to 1 of 25 at 50 ms and 13 of 25 at 100 ms
  [arxiv:2412.02140 tab. 2]. The paper does not say how a text query is matched
  to the 16-dimensional features [arxiv:2412.02140 §3.4].

### Driving scenes with dynamic actors (DriveSplat)

Card: [DriveSplat: Unified Neural Gaussian Reconstruction for Dynamic Driving Scenes](/papers/2508.15376).

Splits a driving scene into one background and tracked actors, both made of
neural Gaussians.

- **Background.** A hashed, multi-scale neural-Gaussian representation. The
  background points are cut into near, mid and far regions by depth along
  their main axis, and each anchor is drawn at a level that depends on its
  distance to the camera [arxiv:2508.15376 §3.2].
- **Actors.** Each tracked actor has a rigid pose per frame. Non-rigid actors
  add an MLP that moves their anchors [arxiv:2508.15376 §3.3].
- **Priors.** Pretrained depth and normal models supervise the fit. The paper
  uses relative depth for the depth term [arxiv:2508.15376 §3.4].
- **Reported results (author-reported).** Novel-view PSNR 33.83 on Waymo and
  24.53 on KITTI [arxiv:2508.15376 tab. 1] [arxiv:2508.15376 tab. 2]. In the
  initialisation ablation, random points give PSNR 29.64 against 33.83 for the
  final SfM plus LiDAR setup [arxiv:2508.15376 tab. 6].
- **Cost.** About 68 minutes on one L20 for 30k iterations, per the text
  [arxiv:2508.15376 §4.2]. The efficiency table gives 69.6 minutes
  [arxiv:2508.15376 tab. 5].

### Driving scenes with diffusion refinement (Hybrid Gaussian Splatting)

Card: [Hybrid Gaussian Splatting for Novel Urban View Synthesis](/papers/2510.12308).

A 3DGS fit renders the target view, and a one-step diffusion model cleans the
render with the nearest source frame as a reference.

- **Initialisation.** The authors rebuild the sparse challenge point cloud
  with COLMAP, sparse then dense, and call this the main lever
  [arxiv:2510.12308 §3.1]. Target-view score rises from 0.319 with the
  challenge cloud to 0.346 with dense COLMAP points [arxiv:2510.12308 fig. 3].
- **Enhancer.** Derived from SD-Turbo and the public Difix checkpoint. Its
  input is the render plus a reference view, and its output is the frame
  [arxiv:2510.12308 §3.2] [arxiv:2510.12308 eq. 4].
- **Training data.** Pairs of corrupted renders and clean frames from two
  datasets, 36,231 in total [arxiv:2510.12308 §3.2].
- **Reported results (author-reported).** Devset score rises from 0.423 for the
  pretrained enhancer to 0.462 after fine-tuning and higher-resolution
  training [arxiv:2510.12308 tab. 1]. The leaderboard score is 0.432, second
  of 28 entries [arxiv:2510.12308 §1].
- **Limits.** Extrapolation to a different trajectory, such as a perpendicular
  path, remains a failure mode [arxiv:2510.12308 §4]. Iterative refinement
  helped the visuals but not the metric, and was left out of the submission
  [arxiv:2510.12308 §4].

### Nighttime relighting (physically based Gaussian splatting)

Card: [Nighttime Autonomous Driving Scene Reconstruction with Physically-Based Gaussian Splatting](/papers/2602.13549).

Gives each Gaussian material properties and adds two light terms, so that
headlights and street lamps are shaded instead of baked into colour.

- **Diffuse light.** A global module predicts second-order spherical-harmonic
  coefficients from the camera and the timestep. The diffuse term is a sum
  over those coefficients [arxiv:2602.13549 §3.4] [arxiv:2602.13549 eq. 4].
- **Specular light.** Each Gaussian has four anisotropic spherical-Gaussian
  lobes. A simplified Disney BRDF uses albedo, roughness and metalness
  [arxiv:2602.13549 §3.3] [arxiv:2602.13549 §3.5].
- **Tone mapping.** Diffuse and specular radiance are summed in HDR, compressed
  with Reinhard and then rasterised [arxiv:2602.13549 §3.6].
- **Reported results (author-reported).** Waymo reconstruction PSNR 31.9
  against 31.0 for OmniRe, and nuScenes 29.7 against 28.7
  [arxiv:2602.13549 tab. 1] [arxiv:2602.13549 tab. 2]. Without the global
  diffuse module, reconstruction PSNR falls to 30.1 from 30.8
  [arxiv:2602.13549 tab. 3].
- **Limits.** Real-time rendering is claimed, but no frame rate, memory or
  training time is reported [arxiv:2602.13549 §1]. Each sequence is optimised
  on its own, which the authors name as a scaling limit [arxiv:2602.13549 §5].

### Feed-forward 4D driving reconstruction (ReconDrive)

Card: [ReconDrive: Fast Feed-Forward 4D Gaussian Splatting for Autonomous Driving Scene Reconstruction](/papers/2603.07552).

One network pass takes two frames from six cameras and returns Gaussians for
the whole segment. Vehicles get one velocity each.

- **Backbone.** A frozen VGGT-style 3D foundation model with LoRA adapters of
  rank 8 and scale 32 [arxiv:2603.07552 §3.2].
- **Heads.** One head predicts a depth per pixel, which is unprojected with the
  calibration into Gaussian centres. A second head predicts rotation, scale,
  opacity and colour, and also sees the raw image [arxiv:2603.07552 §3.2].
- **Motion and composition.** Each vehicle gets one velocity from the
  displacement of its box centre between the two frames. The second frame is
  moved into the first frame's ego coordinates [arxiv:2603.07552 §3.3]
  [arxiv:2603.07552 eq. 3] [arxiv:2603.07552 eq. 4].
- **Reported results (author-reported).** nuScenes reconstruction PSNR 32.66
  against 29.58 for PVG, the best per-scene baseline. Generation takes about
  15 s per scene, against 23 to 46 minutes for the per-scene baselines
  [arxiv:2603.07552 tab. 1].
- **Ablation.** Two context frames give novel-view PSNR 23.99, against 23.54
  for one frame [arxiv:2603.07552 tab. 3].
- **Scope.** Non-rigid and non-linear motion are not supported, and disocclusion
  holes appear where a moved vehicle uncovers background [arxiv:2603.07552 §5].

### Feed-forward dynamic humans (Forge4D)

Card: [Forge4D: Feed-Forward 4D Human Reconstruction and Interpolation from Uncalibrated Sparse-view Videos](/papers/2509.24209).

Takes four uncalibrated video streams of a person or a human-object scene. One
pass predicts per-frame pixel-aligned Gaussians, and a second output predicts
their motion. New times are then shown by moving and merging the Gaussians of
two neighbouring frames [arxiv:2509.24209 §3.4].

- **Backbone and gauge.** The network is VGGT, started from its pre-trained
  weights. Its outputs are in normalised units, so a gauge scales the
  translations to metric units [arxiv:2509.24209 §3.2] [arxiv:2509.24209 §4.1].
  Without the gauge, static PSNR falls to 13.29 [arxiv:2509.24209 tab. 7].
- **Temporal state.** A learnable state token carries information from earlier
  frames, so all frames are not attended to at once [arxiv:2509.24209 §3.3].
  Without it, novel-time PSNR falls from 29.04 to 28.56 [arxiv:2509.24209 tab. 7].
- **Motion and fusion.** The motion head predicts backward and forward 3D motion
  between neighbouring frames. A constant-velocity step moves the Gaussians to
  the target time. Occluded Gaussians are kept apart, and the rest are merged by
  a two-layer MLP [arxiv:2509.24209 §3.4] [arxiv:2509.24209 eq. 5]
  [arxiv:2509.24209 eq. 8].
- **Training without motion labels.** One loss renders frame t moved to t−1 and
  compares it with frame t−1. A flow loss matches predicted 2D scene flow to an
  optical-flow model's output, and a cyclic-consistency weight drops occluded
  pixels [arxiv:2509.24209 §3.4] [arxiv:2509.24209 eq. 6]
  [arxiv:2509.24209 eq. 7].
- **Reported results (author-reported).** DNA-Rendering, four views, novel-view
  PSNR 29.82 against 26.12 for AnySplat, which takes no poses
  [arxiv:2509.24209 tab. 1]. Novel time and view with eight input frames gives
  PSNR 29.04 against 18.03 for L4GM [arxiv:2509.24209 tab. 2]. A fusion ablation
  gives flicker 0.54 against 0.94 without fusion [arxiv:2509.24209 §4.3].
- **Cost.** One input frame pair takes 224 ms, or 4.45 FPS. Interpolation adds
  about 1.5 ms for ten steps, so output can reach 44 FPS
  [arxiv:2509.24209 tab. 6]. The speed figures are the authors' own.
- **Limits.** The constant-velocity model loses quality over longer gaps:
  PSNR 27.91 at sampling rate 4 and 25.97 at 8 [arxiv:2509.24209 tab. 9].
  Dense motion is only checked on a synthetic set with 11 identities
  [arxiv:2509.24209 app. B] [arxiv:2509.24209 tab. 5]. The code is Apache-2.0,
  but no checkpoints are released, and its stage-3 training script stops
  before the training loop (see the card's Paper vs code section).

### Simulator for policy training (REAP)

Card: [REAP: Reinforcement-Learning End-to-End Autonomous Parking with Gaussian Splatting Simulator for Real2Sim2Real Transfer](/papers/2605.08713).

Here the splat scene is a training environment, not the product. A camera-only
parking policy is trained in it, and the policy is then run on a real car.

- **Scene capture.** A handheld LiDAR and camera scan builds the scene. The
  LiDAR points initialise the Gaussians, which gives real-scale reconstructions
  [arxiv:2605.08713 §5.1].
- **Policy.** Soft Actor-Critic. The actor sees only surround-view images, and
  the critic also gets simulator bird's-eye-view maps during training
  [arxiv:2605.08713 §4.2].
- **Planner teacher.** A Reeds-Shepp planner supplies behaviour cloning. Its
  probability falls linearly to zero over 8,000 epochs [arxiv:2605.08713 §4.2]
  [arxiv:2605.08713 §5.3].
- **Reported results (author-reported).** Simulated parking success 83.5% on
  standard slots and 70.0% on mechanical slots [arxiv:2605.08713 tab. 1]. Real
  vehicle success is 55 to 85% across five scenarios [arxiv:2605.08713 tab. 4].
- **Cost.** About one hour to build the scene for an underground lot, and 53 FPS
  in simulation [arxiv:2605.08713 tab. 3].
- **Limits.** Generalisation to unseen outdoor scenes and to dynamic obstacles
  is not established, and there is no formal safety guarantee
  [arxiv:2605.08713 §6].

### Text-to-3D generation (GSGEN)

Card: [Text-to-3D using Gaussian Splatting](/papers/2309.16585).

Makes an object from a text prompt. The Gaussians start from a Point-E point
cloud and are optimised with score distillation against Stable Diffusion
v1.5 [arxiv:2309.16585 §4.1] [arxiv:2309.16585 §4.3] [arxiv:2309.16585 §5.1].

- **Geometry stage.** The 2D term is combined with a 3D term on the Gaussian
  centres only, using Point-E as the 3D prior [arxiv:2309.16585 eq. 3]. The
  weights are 0.1 for the 2D term and 0.01 for the 3D term [arxiv:2309.16585 §5.1].
- **Appearance stage.** Only the 2D term drives colour and opacity. A
  position penalty and an opacity penalty are added, and new Gaussians are
  placed where neighbours leave a gap [arxiv:2309.16585 §4.2]
  [arxiv:2309.16585 eq. 4].
- **Reported results (author-reported).** No quantitative metric. Visually,
  the paper reports fewer collapsed or multi-face assets than DreamFusion,
  ProlificDreamer and Fantasia3D on prompts such as a panda or corgi, and
  finer detail than Magic3D on textured prompts [arxiv:2309.16585 §5.2]
  [arxiv:2309.16585 fig. 2] [arxiv:2309.16585 fig. 5]. About 40 minutes per
  asset on one RTX 3090, which the paper calls on par with Magic3D and
  Fantasia3D [arxiv:2309.16585 app. A] [arxiv:2309.16585 §5.2].
- **Cost.** About 1e5 to 1e6 Gaussians after densification [arxiv:2309.16585 app. A].
- **Limits.** The paper says the Janus problem is reduced, not removed, and
  complex scene descriptions fail [arxiv:2309.16585 §6] [arxiv:2309.16585 app. C].
  Densification is sensitive to the split threshold: a small value over-densifies
  and a large one over-smooths [arxiv:2309.16585 §5.3].

### Large scenes with a level-of-detail hierarchy (Hierarchical 3DGS)

Card: [Hierarchical 3DGS](/papers/2406.12080).

Keeps the splat renderer and adds a tree over the Gaussians. Distant regions
draw merged parents and near regions draw their children
[arxiv:2406.12080 §4.1] [arxiv:2406.12080 §4.2].

- **Tree.** Children are merged bottom-up into a parent with a weighted mean
  and covariance, weighted by opacity times an ellipsoid surface term
  [arxiv:2406.12080 eq. 3] [arxiv:2406.12080 eq. 4] [arxiv:2406.12080 eq. 8].
- **Cut.** For each view, a node is drawn when its projected granularity meets
  the target in pixels and its parent's does not [arxiv:2406.12080 §4.2].
- **Transition.** Position, colour and spherical harmonics blend linearly
  between a node and its parent. The opacity of the children starts at a
  value that keeps their colour equal to the parent's
  [arxiv:2406.12080 eq. 10] [arxiv:2406.12080 eq. 12] [arxiv:2406.12080 §5.2].
- **Chunks.** Each chunk is trained on its own, with depth regularisation and
  per-image exposure compensation, and the chunks are consolidated into one
  scene [arxiv:2406.12080 §6.1] [arxiv:2406.12080 app. C.2]
  [arxiv:2406.12080 §6.3]. Chunks are 50 by 50 m for walking captures and
  100 by 100 m for vehicle captures [arxiv:2406.12080 §6].
- **Reported results (author-reported).** On one SmallCity chunk, leaves
  reach PSNR 26.62 at 58 FPS, against 25.34 and 99 FPS for 3DGS. The
  optimised cut at the middle target reaches 26.29 at 110 FPS
  [arxiv:2406.12080 tab. 2]. Full scenes average 30 FPS or more at the finest
  target and about 60 FPS at the middle one [arxiv:2406.12080 §8.2].
- **Cost.** About 400 bytes per Gaussian in the implementation, 69% more than
  3DGS. Consolidated scenes are 6 to 88 GB [arxiv:2406.12080 §8.2]
  [arxiv:2406.12080 §8.1].
- **Limits.** Pose estimation for each chunk takes 30 minutes to 5 hours
  per chunk [arxiv:2406.12080 app. B]. The authors' code is under a
  research-only licence, so this page relies on the paper alone (see the
  card's Paper vs code section).

### Semantic occupancy memory (GEM-Occ)

Card: [GEM-Occ: From Visual Geometry Evidence to Embodied Semantic Occupancy Memory](/papers/2607.05543).

Builds a persistent map of which space is occupied, free or unknown, with a
semantic label per occupied point. It is fed posed RGB frames from an agent
that moves through static indoor scenes [arxiv:2607.05543 §3] [arxiv:2607.05543 app. A.3].

- **Observation.** Each surface point the network predicts becomes an occupied
  semantic Gaussian. The visible space in front of the surface becomes
  free-space evidence [arxiv:2607.05543 §3.1] [arxiv:2607.05543 eq. 1].
- **Fusion.** A new Gaussian is matched to the nearest memory element by
  Mahalanobis distance. Matched elements are fused with a confidence-weighted
  average, with the history discounted by a factor λ [arxiv:2607.05543 §3.2]
  [arxiv:2607.05543 eq. 4] [arxiv:2607.05543 app. B.3].
- **Occupancy.** Log-odds rise on surface matches and fall where free space
  is seen. Occlusion does not lower occupancy [arxiv:2607.05543 §3.2]
  [arxiv:2607.05543 eq. 5].
- **Query.** Occupancy combines the Gaussian responses of nearby elements as
  one minus a product of complements, and the label is the highest-scoring
  class when occupancy passes a threshold [arxiv:2607.05543 eq. 7]
  [arxiv:2607.05543 eq. 8] [arxiv:2607.05543 app. B.5].
- **Hierarchy.** Memory is split into submaps and a connectivity graph, and
  nearby elements are merged periodically [arxiv:2607.05543 §3.3]
  [arxiv:2607.05543 eq. 6].
- **Reported results (author-reported).** HIOcc local IoU 61.37 and mIoU
  57.76, against 60.69 and 55.08 for GPOcc [arxiv:2607.05543 tab. 3]. At
  building level, IoU is 53.8, against 50.4 for flat Gaussian memory, which
  uses 1.36 MB/m² where GEM-Occ uses 0.81 [arxiv:2607.05543 tab. 5].
- **Limits.** Most training and fusion values are not stated, so an
  implementer must choose and tune them [arxiv:2607.05543 app. B.6]. The
  authors' repository holds no implementation yet (see the card's Paper vs
  code section). HIOcc's licence is not stated, and its source datasets have
  their own terms [arxiv:2607.05543 app. C.1].

## When to use which

| Situation | Use | Why |
|---|---|---|
| You need a usable mesh or surface from photos | 2DGS | Normals and median-depth fusion. DTU Chamfer 0.80 vs 1.96 for 3DGS [arxiv:2403.17888 tab. 1] |
| You only need novel-view images | 3DGS, or 2DGS if you still want the geometry | 2DGS image quality is slightly lower on Mip-NeRF 360 and NeRF-Synthetic [arxiv:2403.17888 tab. 4] [arxiv:2403.17888 tab. 7] |
| Training time is tight | 2DGS-15k | 5.5 min per DTU scene, Chamfer 0.83 [arxiv:2403.17888 tab. 1] |
| Storage is limited | 2DGS | 52 MB per DTU scene vs 113 MB for 3DGS in the authors' runs [arxiv:2403.17888 tab. 3] |
| The scene file must be small, for download or a web viewer | Reduced-3DGS | 14 to 29 MB per scene against 412 to 744 MB for the authors' 3DGS re-run, with PSNR changes of −0.32 to +0.16 dB [arxiv:2406.17074 tab. 1]. The size ratio is against a different baseline than the 2DGS row, so the two are not comparable |
| Weak clients must load and render a scene faster | Reduced-3DGS | One WebGL demo scene loaded in 5 s instead of 120 s and ran at 45 FPS instead of 16. This is one demo, not a benchmark [arxiv:2406.17074 §6.1] |
| You have only 3 to 12 posed photos of a scene and cannot capture more | SparseGS | Depth prior and unseen-view regularisers on top of 3DGS. Mip-NeRF 360 with 12 views: PSNR 19.37 against 17.49 for 3DGS [arxiv:2312.00206 tab. 1]. Needs a monocular depth model and, for the unseen-view term, Stable Diffusion 2.1 [arxiv:2312.00206 §3.2] [arxiv:2312.00206 §4.1] |
| You have three posed photos, need real-time rendering, and cannot run Stable Diffusion 2.1 for unseen views | FSGS | Proximity unpooling and a depth prior on 3DGS. LLFF 1/8 PSNR 20.31 at 458 FPS, against 19.86 at 0.21 FPS for SparseNeRF [arxiv:2312.00451 tab. 1]. Needs a monocular depth model for training and pseudo views [arxiv:2312.00451 §3.3] |
| Training GPU memory is the constraint | Neither compression step nor 2DGS as published | The Reduced-3DGS authors say the training memory peak does not drop [arxiv:2406.17074 §5] |
| You have one or a few photos of an object and need a quick reconstruction | Splatter Image (feed-forward) | One network pass with no per-scene fit. 0.451 s for 250 renders on a V100 [arxiv:2312.13150 tab. 7]. Object-centric, relative poses only [arxiv:2312.13150 §2] |
| You have two posed photos of a scene, need a scene rather than an object, and need no per-scene fit | MVSplat | One pass. RealEstate10K PSNR 26.39 vs 25.89 for pixelSplat, 0.044 s per scene on unstated hardware [arxiv:2403.14627 tab. 1]. Needs known poses and depth ranges [arxiv:2403.14627 §3]. The 128-plane cost volume is the main memory cost [arxiv:2403.14627 §3.1] |
| You are new to the field and need its map before choosing a variant | The 2024 survey, then the cards below | Groups the work into eight directions [arxiv:2401.03890 §4] [arxiv:2401.03890 tab. S1]. Its numbers are copied from original papers, so read those for values [arxiv:2401.03890 §6] |
| You have many posed views of one scene and can afford optimisation | 2DGS or 3DGS | Per-scene fitting. 2DGS runs take 5.5 to 10.9 min per DTU scene [arxiv:2403.17888 tab. 1] |
| You build a map online from RGB-D and need only geometry and colour | SplaTAM | Tracks and maps with Gaussians in one loop. Replica tracking error 0.36 cm [arxiv:2312.02126 tab. 1]. Needs known intrinsics and dense depth [arxiv:2312.02126 §5] |
| You build a map online from RGB-D and need a semantic label per surface | GS3LAM | Tracks the pose and maps in one loop with a semantic feature per Gaussian. Replica mIoU 96.63 over four scenes [arxiv:2603.27781 tab. 4]. Requires RGB-D and a label map per frame [arxiv:2603.27781 §3.1] |
| You have only a monocular camera or no depth | Neither as published | GS3LAM assumes RGB-D input [arxiv:2603.27781 §3.1]. SplaTAM needs dense depth [arxiv:2312.02126 §5] |
| The SLAM loop must run in real time | Neither as published | GS3LAM: tracking plus mapping took 7.30 s per frame on Replica Office 0, and its 109 FPS is rendering only [arxiv:2603.27781 app. C.2]. SplaTAM: 1.00 s tracking and 1.44 s mapping per frame on Replica R0, or 0.19 s and 0.33 s for SplaTAM-S [arxiv:2312.02126 tab. 6] |
| You need to select, delete or recolour objects in a reconstructed 3DGS scene, with no 3D labels | Gaussian Grouping | One identity encoding per Gaussian from SAM masks tracked across views. LERF-Mask figurines mIoU 69.7 [arxiv:2312.00732 tab. 3]. Static scenes only [arxiv:2312.00732 §4.4] |
| You need text or point queries on a 3DGS scene and can afford a per-view teacher pass | Feature 3DGS | Distils LSeg or SAM features into each Gaussian. Replica mIoU 0.782 vs 0.636 for NeRF-DFF [arxiv:2312.03203 tab. 2]. Its code is research-only [arxiv:2312.03203 Paper vs code] |
| You must grasp a named object in a scene that moves, from about three RGB views, and can run DUSt3R and MaskCLIP | SparseGrasp | Moved objects are re-posed by render-and-compare in about 200 ms. Real arm: 55 of 70 grasps with three views [arxiv:2412.02140 tab. 1]. No official code, so this must be reimplemented [arxiv:2412.02140 §4] |
| You need scene edits or object masks but the 2D teacher model cannot be run per view | Neither as published | Both need per-view masks or features from a 2D model [arxiv:2312.00732 §3.2] [arxiv:2312.03203 §3.1] |
| Scene has glass or other see-through surfaces | Neither as published | 2DGS assumes fully opaque surfaces and fails on glass [arxiv:2403.17888 §7] |
| You need a static Gaussian object to react to new forces, with no measured material data | PhysDreamer | Material is estimated from one generated video, then simulated. Elastic objects only, with no collisions, and slow [arxiv:2404.13026 §4] [arxiv:2404.13026 §6] |
| Contacts or collisions must be simulated | Not PhysDreamer as published | Collisions are excluded [arxiv:2404.13026 §6] |
| You must render a recorded night drive from new viewpoints | Physically based relighting | Diffuse and specular light terms for headlights and lamps. Waymo reconstruction PSNR 31.9 vs 31.0 for OmniRe [arxiv:2602.13549 tab. 1]. Per-sequence optimisation, and no frame rate reported [arxiv:2602.13549 §1] [arxiv:2602.13549 §5] |
| You need novel views of a logged driving scene with other vehicles in it, and have LiDAR and depth or normal priors | DriveSplat | Separate background and tracked actors. Waymo novel-view PSNR 33.83 [arxiv:2508.15376 tab. 1]. About 68 min per scene on one L20 [arxiv:2508.15376 §4.2] |
| You have four uncalibrated video streams of a person or human-object scene and need novel views and novel times without a fit per scene | Forge4D | One pass per frame pair, 224 ms on the authors' H200. DNA-Rendering novel-time PSNR 29.04 against 18.03 for L4GM [arxiv:2509.24209 tab. 2]. No checkpoints are released, so the model must be trained from VGGT [arxiv:2509.24209 §4.1] (see the card's Paper vs code section) |
| You must reconstruct many driving scenes quickly from six calibrated cameras, and can accept vehicle boxes and ego poses as input | ReconDrive | One forward pass per two-frame segment, about 15 s per scene [arxiv:2603.07552 tab. 1]. Vehicles move linearly only [arxiv:2603.07552 §5]. The released code reads boxes and poses from annotations; see the card's Paper vs code section |
| You have a 3DGS fit and need views shifted by one or two lanes, or from the opposite direction, with no per-view model beyond one enhancer | Hybrid 3DGS with one-step diffusion enhancer | Dense COLMAP initialisation and a fine-tuned enhancer. Leaderboard score 0.432, second of 28 [arxiv:2510.12308 §1]. A perpendicular trajectory is a known failure [arxiv:2510.12308 §4] |
| You need a policy trained in a reconstructed scene and run on a real vehicle with camera input only | REAP-style 3DGS simulator with a planner teacher | Simulated parking success 83.5% on standard slots [arxiv:2605.08713 tab. 1]. Needs a LiDAR scan of the site and a Reeds-Shepp planner during training [arxiv:2605.08713 §5.1] [arxiv:2605.08713 §4.2] |
| You need a 3D object from a text prompt, and about 40 minutes per asset on one GPU is acceptable | GSGEN | Point-E start, 2D and 3D score distillation in the geometry stage. Results are visual only; fewer Janus artefacts than the baselines in its figures [arxiv:2309.16585 §5.2] [arxiv:2309.16585 fig. 2] |
| You must render a city-scale capture in real time, and the whole scene does not fit in GPU memory | Hierarchical 3DGS | Tree of merged Gaussians with per-view cuts. One SmallCity chunk at the middle target: PSNR 26.29, 110 FPS [arxiv:2406.12080 tab. 2]. Storage about 68% above non-hierarchical 3DGS [arxiv:2406.12080 §8.1]. The code is research-only |
| A robot must keep a semantic occupancy map of a static indoor building it revisits, from posed RGB frames | GEM-Occ | Persistent memory with free-space evidence. Local IoU 61.37 on HIOcc [arxiv:2607.05543 tab. 3]. No implementation is released yet, so the values marked "not stated" must be chosen [arxiv:2607.05543 app. B.6] |
| You have two to eight photos from unknown camera positions and need the poses and a scene in one pass, with no per-scene fit | FLARE | Predicts poses, point maps and Gaussians together. AUC@30° 79.9 on RealEstate10K against 61.1 for MASt3R [arxiv:2502.12138 tab. 1]. Takes uncalibrated inputs; the novel-view model on RealEstate10K uses intrinsics [arxiv:2502.12138 §4.3]. Built for 2 to 8 views [arxiv:2502.12138 §1] |
| You have two posed views with known intrinsics, need a feed-forward result at low latency, and the two-view setting is enough | iLRM | RealEstate10K two views: PSNR 28.65 at 0.025 s, against 27.47 at 0.065 s for DepthSplat [arxiv:2507.23277 tab. 1]. Only the two-view, full-resolution setting is in the released code (see its card's Paper vs code section) |
| You plan to ship a commercial product | Reimplement from the paper | The FLARE repository is CC BY-NC-SA 4.0, so its code is not usable (see the FLARE card's code licence field). The iLRM repository has no LICENSE file (see its card's Paper vs code section). The Gaussian Grouping repository is Apache-2.0, but its pipeline also runs SAM, DEVA and LaMa, whose licences were not checked here (see its card's code licence field). The Feature 3DGS repository is under a research-only licence that bars commercial use without consent (see its card's Paper vs code). The 2DGS authors' code is under a non-commercial licence (see the 2DGS card's code licence field). The Splatter Image repository is BSD-3-Clause, but some adapted files are non-commercial (see the Splatter Image card's code licence field). The PhysDreamer repository has no LICENSE file (see the PhysDreamer card's code licence field). The Reduced-3DGS code is under a non-commercial licence (see its card's code licence field). The GS3LAM repository has no LICENSE file, and its rasteriser is non-commercial (see its card's code licence field). The SparseGS repository is under a non-commercial research licence (see its card's code licence field). The FSGS repository is under the Gaussian-Splatting License, which allows research use only (see the FSGS card's code licence field). The Forge4D repository is Apache-2.0, but it ships no checkpoints and its vendored layers and VGGT backbone were not audited (see the Forge4D card's Pitfalls). The SplaTAM repository is BSD-3-Clause, but its rasteriser is an external submodule that is not in the repository and its licence was not checked (see the SplaTAM card's Pitfalls). The DriveSplat repository has no LICENSE file (see its card's code licence field). The ReconDrive licence is not stated (see its card's code licence field). The MVSplat repository is MIT, but the UniMatch checkpoint it loads is not in the repository, and its licence was not checked here (see the MVSplat card's Paper vs code section). The Hierarchical 3DGS repository is under a research-only Inria licence that bars commercial use without consent (see its card's code licence field). The GSGEN repository is MIT, but the models it loads were not checked here (see its card's code licence field). The GEM-Occ repository is MIT and holds only a README and a licence, so there is nothing to ship yet. The nighttime relighting, Hybrid, REAP and SparseGrasp papers publish no code (see their cards' Paper vs code sections) |

## Implementation sketch

Common core of the per-pixel renderer. Variants differ in the marked lines.
Feed-forward variants such as Splatter Image render the same way, but the
splats come from a network rather than from optimisation [arxiv:2312.13150 §3.1].
Labelling variants such as GS3LAM, Gaussian Grouping and Feature 3DGS also
blend a per-Gaussian vector with the same weights [arxiv:2603.27781 eq. 7]
[arxiv:2312.00732 eq. 1] [arxiv:2312.03203 eq. 3].

```pseudocode
# Per-pixel splat renderer, front-to-back blending  [arxiv:2403.17888 §4.2]
def render_pixel(ray, splats_sorted_by_depth):
    colour, transmittance = 0, 1
    for s in splats_sorted_by_depth:
        # 3DGS: affine projection. 2DGS: exact ray-splat hit  [§3] [§4.2]
        g = splat_response(s, ray)
        # low-pass floor only in 2DGS, for edge-on splats  [eq. 11]
        alpha = s.opacity * g
        colour += transmittance * alpha * s.colour
        # Labelling variants: the same weights blend a vector  [GS3LAM eq. 7]
        # vec += transmittance * alpha * s.vec  [Gaussian Grouping eq. 1]
        transmittance *= 1 - alpha
        # stop once the pixel is saturated; threshold not stated in paper
        if saturated(transmittance):
            break
    # 2DGS also returns depth, normal and distortion  [§6.1] [§5]
    return colour
```

## Contradictions

- **Distortion weight.** The paper gives α as 1000 for bounded and 100 for
  unbounded scenes [arxiv:2403.17888 §5]. The card's Paper vs code section
  records that the released code defaults to 0 and that the Tanks and Temples
  and Mip-NeRF 360 scripts do not pass a value. Which α produced the reported
  numbers for those benchmarks is therefore uncertain
  [arxiv:2403.17888 tab. 2] [arxiv:2403.17888 tab. 4].
- **Depth for the normal target.** The paper uses the median depth point
  [arxiv:2403.17888 §5]. The card records that the code defaults to expected
  depth for unbounded scenes.
- **Baseline numbers.** Most baselines in the Mip-NeRF 360 table are copied
  from the original papers, while the 3DGS, SuGaR and 2DGS rows were rerun by
  the authors [arxiv:2403.17888 tab. 4]. Compare with that in mind.
- **3DGS baseline re-runs.** Reduced-3DGS reruns 3DGS and reports 27.42 PSNR
  and 744 MB on Mip-NeRF 360, which it says are not the numbers printed in the
  3DGS paper [arxiv:2406.17074 tab. 1] [arxiv:2406.17074 §6.2]. The 2DGS paper
  reruns 3DGS too, with different scenes and settings, so do not compare
  baseline figures across the cards. Gaussian Grouping's 3DGS row is 28.69
  PSNR on seven Mip-NeRF 360 scenes [arxiv:2312.00732 tab. 1], and Feature
  3DGS's base 3DGS row is 36.13 PSNR on Replica [arxiv:2312.03203 tab. 1]. SparseGS reports 17.49 PSNR for 3DGS with
  12 input views on Mip-NeRF 360 [arxiv:2312.00206 tab. 1], a sparse-view setting
  that is not comparable with the dense-view figures above.
- **SparseGS gain from the pruning step.** The text gives 0.28 dB for pruning and
  0.33 dB on average for the unseen-view term. The ablation table gives 0.23 dB
  for the unseen-view step (19.09 minus 18.86) [arxiv:2312.00206 §4.3]
  [arxiv:2312.00206 tab. 3]. The paper does not explain the gap.
- **Speed-up factors (Splatter Image).** The text says training is 246 times
  faster than implicit methods, while the table gives about 225 times against
  PixelNeRF and about 295 times against VisionNeRF [arxiv:2312.13150 §4.2]
  [arxiv:2312.13150 tab. 7]. On CO3D the text says 1,000 times faster, and the
  Figure 4 caption says 100 times [arxiv:2312.13150 §4.1.1] [arxiv:2312.13150 fig. 4].
- **Inside GS3LAM.** The text gives a 2.22 dB PSNR gain for the unobserved-region
  mask, while the ablation table gives 2.11 dB (41.21 minus 39.10)
  [arxiv:2603.27781 §4.5] [arxiv:2603.27781 tab. 5]. The text also says five
  ScanNet subsets where the tables show six [arxiv:2603.27781 §4.1]
  [arxiv:2603.27781 tab. 1].
- **SplaTAM keyframe choice.** The SplaTAM text takes the earlier keyframes with
  the highest overlap with the current frame [arxiv:2312.02126 §3]. Its released
  code instead shuffles the overlapping keyframes and keeps the first few, as
  the SplaTAM card's Paper vs code section records. GS3LAM presents its random
  sampling as a replacement for SplaTAM's keyframe selection
  [arxiv:2603.27781 §3.3.3]. Use the paper's rule or the code's, and say which.
- **Waymo baselines in two driving papers.** DriveSplat's table gives 3DGS
  reconstruction PSNR 33.15 and OmniRe 34.57 on Waymo [arxiv:2508.15376 tab. 1].
  The nighttime paper gives 30.1 and 31.0 on its own Waymo set, which is 11 night
  scenes [arxiv:2602.13549 tab. 1] [arxiv:2602.13549 §4.1]. DriveSplat uses 12
  sequences [arxiv:2508.15376 §4.1]. The scenes differ, so compare the gains
  within each table and not the absolute values across them.
- **Within DriveSplat.** The text says it has the best reconstruction SSIM and
  LPIPS on Waymo [arxiv:2508.15376 §4.3]. Its table has OmniRe at SSIM 0.939
  against 0.937 for DriveSplat [arxiv:2508.15376 tab. 1]. The text also claims
  the best reconstruction on KITTI, while OmniRe has the higher reconstruction
  PSNR, 28.68 against 28.59 [arxiv:2508.15376 §4.3] [arxiv:2508.15376 tab. 2].
- **Vehicle motion in ReconDrive.** Section 3.1 says the dynamic motion is
  regressed, and section 3.3 says it is computed from annotated boxes
  [arxiv:2603.07552 §3.1] [arxiv:2603.07552 §3.3]. The card's Paper vs code
  section records that the released code uses the boxes.
- **Few-view LLFF baselines.** FSGS gives 3D-GS 17.43 PSNR on LLFF with three
  views at 1/8 resolution, and 16.94 at 1/4 [arxiv:2312.00451 tab. 1]. SparseGS
  gives 16.94 for 3DGS on LLFF [arxiv:2312.00206 tab. 2]. The resolution of the
  SparseGS figure is not given on this page, so the two should not be compared
  directly.
- **Depth model in FSGS.** The main text names DPT [arxiv:2312.00451 §3.3]. The
  appendix links the MiDaS v2 model and says it outputs inverse depth
  [arxiv:2312.00451 app. Training]. The FSGS card's Pitfalls note that the
  DPT Large row of its depth-estimator table matches the main results, which
  suggests DPT was used. Inverse depth is compared with rendered z-depth
  without a conversion stated [arxiv:2312.00451 eq. 7].
- **Forge4D hardware.** Section 4.3 gives an H200 for the speed table
  [arxiv:2509.24209 §4.3]. The appendix comparison says H20
  [arxiv:2509.24209 app. E].
- **Forge4D static and temporal tables.** Table 1 disables the state token and
  state attention, so it is not the same model as Table 2
  [arxiv:2509.24209 app. C] [arxiv:2509.24209 tab. 1] [arxiv:2509.24209 tab. 2].
- **Two-view and dense-view numbers.** MVSplat's RealEstate10K results use two
  context views at 256 × 256 [arxiv:2403.14627 tab. 1]. Its PSNR values are not
  comparable with the dense-view Mip-NeRF 360 figures above, or with the
  12-view SparseGS figures.
- **REAP's simulator numbers.** The same 3DGS simulator scores 82.5% simulated
  parking success in one table and 83.5% in another [arxiv:2605.08713 tab. 3]
  [arxiv:2605.08713 tab. 1].
- **SparseGrasp mask model.** Section 3.1 and the figure 2 caption name FastSAM
  for masks, while section 4 says SAM ViT-H [arxiv:2412.02140 §3.1]
  [arxiv:2412.02140 §4]. The paper does not say which one produced its results.
- **FLARE reconstruction claim.** The text says FLARE achieves higher
  performance than DUSt3R, MASt3R and Spann3R [arxiv:2502.12138 §4.2]. On ETH3D,
  MASt3R has the lower overall error, 0.3522 against 0.4978 for FLARE
  [arxiv:2502.12138 tab. 2].
- **SparseGrasp novel views.** The text says the method is strong on novel
  views, while the table gives 0.71 IoU for it against 0.75 for F3RM with 17
  views [arxiv:2412.02140 §4.1] [arxiv:2412.02140 tab. 3].

## Papers

- [A Survey on 3D Gaussian Splatting](/papers/2401.03890): a survey that groups follow-up work into eight directions and collects author-reported benchmarks from the original papers.
- [MVSplat: Efficient 3D Gaussian Splatting from Sparse Multi-View Images](/papers/2403.14627): a cost volume over 128 depth planes from two posed views, refined by U-Nets, predicts one Gaussian per pixel in one pass.
- [2D Gaussian Splatting for Geometrically Accurate Radiance Fields](/papers/2403.17888): flat oriented 2D Gaussians with ray-splat intersection and depth and normal losses, for accurate meshes from splats.
- [Splatter Image: Ultra-Fast Single-View 3D Reconstruction](/papers/2312.13150): one 3D Gaussian per pixel predicted by a U-Net from one image, rendered with Gaussian Splatting for feed-forward object reconstruction.
- [SparseGS: Sparse View Synthesis using 3D Gaussian Splatting](/papers/2312.00206): a monocular depth prior, score distillation on unseen views and floater pruning, for 3DGS fits from 3 to 12 photos.
- [PhysDreamer: Physics-Based Interaction with 3D Objects via Video Generation](/papers/2404.13026): per-particle Young's modulus for a static Gaussian object, fitted to a generated video through MPM and differentiable rendering.
- [Reducing the Memory Footprint of 3D Gaussian Splatting](/papers/2406.17074): pruning, colour-band reduction and k-means codebooks that shrink a 3DGS scene about 27 times on disk.
- [SplaTAM: Splat, Track & Map 3D Gaussians for Dense RGB-D SLAM](/papers/2312.02126): tracks each frame against a fixed Gaussian map, densifies where the map is empty and refines it on keyframes, for dense RGB-D SLAM.
- [GS3LAM: Gaussian Semantic Splatting SLAM](/papers/2603.27781): RGB-D SLAM with a semantic feature per Gaussian, tracked against a frozen map and mapped with random keyframe sampling.
- [Gaussian Grouping: Segment and Edit Anything in 3D Scenes](/papers/2312.00732): a 16-dimensional identity encoding per Gaussian, trained from tracked SAM masks, for object-level segmentation and editing.
- [Feature 3DGS: Supercharging 3D Gaussian Splatting to Enable Distilled Feature Fields](/papers/2312.03203): distils a 2D teacher's features into each Gaussian through the same splatting, for text and point queries on a scene.
- [DriveSplat: Unified Neural Gaussian Reconstruction for Dynamic Driving Scenes](/papers/2508.15376): a hashed multi-scale background and tracked actors with per-anchor deformation, fitted with depth and normal priors for driving scenes.
- [Hybrid Gaussian Splatting for Novel Urban View Synthesis](/papers/2510.12308): a 3DGS fit on COLMAP-densified points, with a one-step diffusion enhancer that cleans the render for street-view synthesis.
- [Nighttime Autonomous Driving Scene Reconstruction with Physically-Based Gaussian Splatting](/papers/2602.13549): diffuse spherical-harmonic and specular anisotropic-lobe light per Gaussian, with Reinhard tone mapping, for night driving scenes.
- [SparseGrasp: Robotic Grasping via 3D Semantic Gaussian Splatting from Sparse Multi-View RGB Images](/papers/2412.02140): a 3DGS scene from three RGB views with distilled MaskCLIP features, updated by render-and-compare after objects move, for language-guided grasping.
- [ReconDrive: Fast Feed-Forward 4D Gaussian Splatting for Autonomous Driving Scene Reconstruction](/papers/2603.07552): a LoRA-adapted 3D foundation model that outputs 4D Gaussians for a two-frame, six-camera segment in one pass.
- [REAP: Reinforcement-Learning End-to-End Autonomous Parking with Gaussian Splatting Simulator for Real2Sim2Real Transfer](/papers/2605.08713): a 3DGS simulator built from LiDAR and camera scans, in which a camera-only parking policy is trained with SAC and a planner teacher.
- [FSGS: Real-Time Few-shot View Synthesis using Gaussian Splatting](/papers/2312.00451): proximity-guided Gaussian unpooling and pseudo views with a monocular depth correlation loss, for 3DGS fits from three photos.
- [Forge4D: Feed-Forward 4D Human Reconstruction and Interpolation from Uncalibrated Sparse-view Videos](/papers/2509.24209): a VGGT-based network that predicts per-frame Gaussians and dense 3D motion from four uncalibrated human videos, for novel views and novel times.
- [Text-to-3D using Gaussian Splatting](/papers/2309.16585): Point-E initialisation and 2D and 3D score distillation over Gaussians, with compactness-based densification, for text-to-3D objects.
- [Hierarchical 3DGS](/papers/2406.12080): a tree of merged Gaussians with per-view cuts and smooth level switching, trained in chunks, for very large street-level scenes.
- [GEM-Occ: From Visual Geometry Evidence to Embodied Semantic Occupancy Memory](/papers/2607.05543): a persistent semantic occupancy memory of Gaussians with log-odds and free-space evidence, fused from posed RGB observations.
- [FLARE: Feed-forward Geometry, Appearance and Camera Estimation from Uncalibrated Sparse Views](/papers/2502.12138): a pose-first transformer that predicts camera poses, point maps and 3D Gaussians from 2 to 8 uncalibrated views in one pass.
- [iLRM: An Iterative Large 3D Reconstruction Model](/papers/2507.23277): viewpoint tokens from Plücker rays, refined over twelve cross- and self-attention layers, predict Gaussians from posed images in one pass.