Gaussian splatting

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 2403.17888 §3 2403.17888 §5.

The reference point is 3D Gaussian Splatting (arXiv: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 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 2401.03890 §4 2401.03890 tab. S1. The survey adds no new method. Its benchmark numbers are copied from the original papers, so read those for values 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 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 2312.13150 §3.2. Two-view variants can place depth by matching features across the views, rather than reading depth from one image 2403.14627 §1. Some feed-forward variants also estimate the camera poses from uncalibrated images 2502.12138 §3.1, while another takes poses and intrinsics as inputs 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 2312.00206 §1. FSGS instead grows the Gaussian set where neighbours are far apart, and uses a depth prior without a diffusion model 2312.00451 §3.2 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 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 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 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 2312.02126 §3. GS3LAM also attaches an extra per-primitive feature, a semantic code, that is blended like colour 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 2312.00732 §3.2, or a distilled feature from a 2D foundation model that supports text and point queries 2312.03203 §3.1 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 2412.02140 §3.2 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 2508.15376 §3.3 2602.13549 §3.2 2603.07552 §3.2. Refinement variants keep a Gaussian render and clean it with a diffusion model afterwards 2510.12308 §3.2. One paper uses a scanned Gaussian scene only as the simulator in which a parking policy is trained 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 2309.16585 §4.1 2309.16585 §4.3. It reports no metric, only visual comparisons 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 2406.12080 §4.1 2406.12080 §4.2. The capture is split into chunks that are trained separately and then combined 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 2607.05543 §3.1 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 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.

• 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 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 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 2403.17888 §5.
• Mesh. Rendered median depth is fused into a mesh with TSDF fusion 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 2403.17888 tab. 1. On Mip-NeRF 360, outdoor PSNR is 24.34 against 24.64 for 3DGS 2403.17888 tab. 4.

Feed-forward prediction (Splatter Image)

Card: Splatter Image: Ultra-Fast Single-View 3D Reconstruction.

• 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 2312.13150 §3.2 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 2312.13150 §3.3 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 2312.13150 §3.4 2312.13150 §3.6.
• Scope. Object-centric reconstruction with relative camera poses only, not generalisation to unseen scenes 2312.13150 §2 2312.13150 app. B.
• Reported results (author-reported). Single view, ShapeNet-SRN cars: PSNR 24.00, the highest value in the paper's table 2312.13150 tab. 1. On Google Scanned Objects, PSNR 21.06 against 18.06 for OpenLRM 2312.13150 tab. 4. Rendering 250 views at 128 × 128 takes 0.451 s on one V100 for one input view 2312.13150 tab. 7.

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

Card: MVSplat: Efficient 3D Gaussian Splatting from Sparse Multi-View Images.

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 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 2403.14627 §3.1 2403.14627 eq. 3 2403.14627 eq. 6.
• Depth refinement. A second, light U-Net predicts a residual depth from the images, features, coarse depth and matching confidence 2403.14627 §3.1 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 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 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 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 2403.14627 tab. 1. Trained on RealEstate10K only, DTU PSNR is 13.94 against 12.89 for pixelSplat 2403.14627 tab. 2.
• Ablation. Without the cost volume, PSNR falls to 22.83 from 26.39 2403.14627 tab. 3.
• Scope. Needs known intrinsics and extrinsics, and a near and far depth range for each view 2403.14627 §3 2403.14627 app. C. It evaluates with two context views, and the model accepts more at test time 2403.14627 §4.2. The paper says reflective surfaces such as glass and windows are unreliable 2403.14627 §5.

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

Card: FLARE: Feed-forward Geometry, Appearance and Camera Estimation from Uncalibrated Sparse Views.

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 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 2502.12138 §3.1 2502.12138 §3.2 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 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 2502.12138 §3.4. The weights of the pose and geometry losses are not stated 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 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 2502.12138 tab. 3 2502.12138 §4.3.
• Cost. About 14 days on 64 GPUs for 200 epochs 2502.12138 §4. The hardware behind the under-0.5 s inference claim is not stated 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 2502.12138 §3.2 2502.12138 tab. 6. The RealEstate10K novel-view model is fine-tuned with intrinsics as a condition 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 2502.12138 §3.3 2502.12138 eq. 6.

Iterative feed-forward with viewpoint tokens (iLRM)

Card: iLRM: An Iterative Large 3D Reconstruction Model.

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 2507.23277 §1 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 2507.23277 §3.2 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 2507.23277 §3.2 2507.23277 eq. 3 2507.23277 eq. 4.
• Output. One linear layer maps each token to Gaussian parameters. Colour is degree-0 only 2507.23277 §3.2 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 2507.23277 §3.3 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 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 2507.23277 tab. 5.
• Ablation. Without iterative refinement, PSNR on the four-view setting falls to 28.58 from 29.24 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) 2507.23277 §3.2 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 2507.23277 app. F.

Sparse views (SparseGS)

Card: SparseGS: Sparse View Synthesis using 3D Gaussian Splatting.

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 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 2312.00206 §3.2 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 2312.00206 §3.3.1 2312.00206 §3.3.2. The distillation term starts after two-thirds of the iterations 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 2312.00206 §3.4 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 2312.00206 tab. 1. LLFF PSNR 19.86 against 16.94 for 3DGS 2312.00206 tab. 2. On DTU the method is level with DNGaussian: PSNR 18.89 against 18.91 2312.00206 tab. 2.
• Cost. The paper gives no hardware or training time 2312.00206 §4.1.

Sparse views without diffusion (FSGS)

Card: FSGS: Real-Time Few-shot View Synthesis using Gaussian Splatting.

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 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 2312.00451 §3.2 2312.00451 eq. 4. The threshold is 10, given without units, so it depends on each scene's scale 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 2312.00451 §3.3 2312.00451 eq. 5 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 2312.00451 §3.3 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 2312.00451 eq. 8.
• Weights. L1 0.8, D-SSIM 0.2 and depth 0.05, found by grid search 2312.00451 §3.4. The weight for the pseudo-view term is not given 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 2312.00451 tab. 1. On LLFF the unpooling step alone gives 18.64, depth regularisation 19.83 and pseudo views 20.31 2312.00451 tab. 4.
• Cost. About 9.5 minutes on LLFF and 24 minutes on Mip-NeRF 360, on one A6000 2312.00451 §4.1. After iteration 2,000 each step also runs the depth model on a rendered pseudo view 2312.00451 alg. 1.
• Scope. Mip-NeRF 360 uses 24 training views and is not a few-shot test 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.

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 2404.13026 §4 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 2404.13026 §4.1 2404.13026 §4.2 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 2404.13026 §4.2 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 2404.13026 §4.3 2404.13026 alg. 1.
• Interaction. After fitting, a new force or initial velocity is applied, the scene is simulated and rendered from any viewpoint 2404.13026 §5.1 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 2404.13026 tab. 1. The study measures perceived realism, not physical accuracy 2404.13026 §5.1. Compute is about one minute on one V100 per second of generated video 2404.13026 §6.
• Limits. Elastic materials only, no collisions. The object is separated from the background and stationary parts are fixed by hand 2404.13026 §6.

Compression (Reduced-3DGS)

Card: Reducing the Memory Footprint of 3D Gaussian Splatting.

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 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 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 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 2406.17074 tab. 1. Rendering is 1.6 to 1.9 times faster per scene, about 1.7 times on average 2406.17074 tab. 2. The authors keep 43% of the baseline primitives 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 2406.17074 §5.

Dense RGB-D SLAM (SplaTAM)

Card: SplaTAM: Splat, Track & Map 3D Gaussians for Dense RGB-D SLAM.

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 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 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 2312.02126 §3 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 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 2312.02126 §3.
• Reported results (author-reported). Replica tracking error averages 0.36 cm, against 0.52 cm for Point-SLAM 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 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 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 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 2312.02126 §5.

Semantic SLAM (GS3LAM)

Card: GS3LAM: Gaussian Semantic Splatting SLAM.

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 2603.27781 §3.2 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 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 2603.27781 §3.3.1 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 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) 2603.27781 §3.3.2 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 2603.27781 §3.1 2603.27781 §3.3.4.
• Reported results (author-reported). On Replica, rendering PSNR 36.26 over eight scenes against 34.11 for SplaTAM 2603.27781 tab. 2. Semantic mIoU 96.63 over four scenes against 87.41 for SNI-SLAM 2603.27781 tab. 4. Tracking ATE 0.37 cm against 0.36 cm for SplaTAM 2603.27781 tab. 3. Rendering runs at 109 FPS on average 2603.27781 app. C.2.

Object segmentation and editing (Gaussian Grouping)

Card: Gaussian Grouping: Segment and Edit Anything in 3D Scenes.

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 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 2312.00732 §3.2 (a)–(d) 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 2312.00732 §3.2 (d) 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 2312.00732 §3.3.
• Reported results (author-reported). LERF-Mask figurines mIoU 69.7 against 33.5 for LERF 2312.00732 tab. 3. On Mip-NeRF 360 the PSNR is 28.43 against 28.69 for 3DGS 2312.00732 tab. 1. Training is 30K iterations in the paper 2312.00732 §4.1.2.
• Limits. Static scenes only 2312.00732 §4.4. Groups are anonymous IDs, so text queries need an extra detector to pick a mask 2312.00732 §4.3. Inpainting needs several extra models per view 2312.00732 app. 3D Object Inpainting Pipeline.

Language feature field (Feature 3DGS)

Card: Feature 3DGS: Supercharging 3D Gaussian Splatting to Enable Distilled Feature Fields.

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 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 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 2312.03203 §3.2 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 2312.03203 §3.3 2312.03203 eq. 5 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 2312.03203 tab. 2. Replica PSNR 37.01 against 36.13 for base 3DGS 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 2312.03203 tab. A.
• Limits. The teacher features are precomputed per view and are large 2312.03203 Pitfalls. The edit threshold is not stated in the paper and is tuned per scene 2312.03203 §3.3.

Grasping in changing scenes (SparseGrasp)

Card: SparseGrasp: Robotic Grasping via 3D Semantic Gaussian Splatting from Sparse Multi-View RGB Images.

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 2412.02140 §3.1 2412.02140 §3.2 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 2412.02140 §3.1 2412.02140 §4 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 2412.02140 §3.1 2412.02140 §3.2 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 2412.02140 §3.3 2412.02140 eq. 6.
• Grasping. GraspNet is retrained to take each Gaussian's centre, scale and rotation instead of a point cloud 2412.02140 §3.4 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 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 2412.02140 tab. 2. Reconstruction takes about 4 minutes, against 10 for F3RM 2412.02140 tab. 4.
• Limits. Adding or removing objects needs a scene refresh 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 2412.02140 tab. 2. The paper does not say how a text query is matched to the 16-dimensional features 2412.02140 §3.4.

Driving scenes with dynamic actors (DriveSplat)

Card: DriveSplat: Unified Neural Gaussian Reconstruction for Dynamic Driving Scenes.

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 2508.15376 §3.2.
• Actors. Each tracked actor has a rigid pose per frame. Non-rigid actors add an MLP that moves their anchors 2508.15376 §3.3.
• Priors. Pretrained depth and normal models supervise the fit. The paper uses relative depth for the depth term 2508.15376 §3.4.
• Reported results (author-reported). Novel-view PSNR 33.83 on Waymo and 24.53 on KITTI 2508.15376 tab. 1 2508.15376 tab. 2. In the initialisation ablation, random points give PSNR 29.64 against 33.83 for the final SfM plus LiDAR setup 2508.15376 tab. 6.
• Cost. About 68 minutes on one L20 for 30k iterations, per the text 2508.15376 §4.2. The efficiency table gives 69.6 minutes 2508.15376 tab. 5.

Driving scenes with diffusion refinement (Hybrid Gaussian Splatting)

Card: Hybrid Gaussian Splatting for Novel Urban View Synthesis.

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 2510.12308 §3.1. Target-view score rises from 0.319 with the challenge cloud to 0.346 with dense COLMAP points 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 2510.12308 §3.2 2510.12308 eq. 4.
• Training data. Pairs of corrupted renders and clean frames from two datasets, 36,231 in total 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 2510.12308 tab. 1. The leaderboard score is 0.432, second of 28 entries 2510.12308 §1.
• Limits. Extrapolation to a different trajectory, such as a perpendicular path, remains a failure mode 2510.12308 §4. Iterative refinement helped the visuals but not the metric, and was left out of the submission 2510.12308 §4.

Nighttime relighting (physically based Gaussian splatting)

Card: Nighttime Autonomous Driving Scene Reconstruction with Physically-Based Gaussian Splatting.

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 2602.13549 §3.4 2602.13549 eq. 4.
• Specular light. Each Gaussian has four anisotropic spherical-Gaussian lobes. A simplified Disney BRDF uses albedo, roughness and metalness 2602.13549 §3.3 2602.13549 §3.5.
• Tone mapping. Diffuse and specular radiance are summed in HDR, compressed with Reinhard and then rasterised 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 2602.13549 tab. 1 2602.13549 tab. 2. Without the global diffuse module, reconstruction PSNR falls to 30.1 from 30.8 2602.13549 tab. 3.
• Limits. Real-time rendering is claimed, but no frame rate, memory or training time is reported 2602.13549 §1. Each sequence is optimised on its own, which the authors name as a scaling limit 2602.13549 §5.

Feed-forward 4D driving reconstruction (ReconDrive)

Card: ReconDrive: Fast Feed-Forward 4D Gaussian Splatting for Autonomous Driving Scene Reconstruction.

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 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 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 2603.07552 §3.3 2603.07552 eq. 3 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 2603.07552 tab. 1.
• Ablation. Two context frames give novel-view PSNR 23.99, against 23.54 for one frame 2603.07552 tab. 3.
• Scope. Non-rigid and non-linear motion are not supported, and disocclusion holes appear where a moved vehicle uncovers background 2603.07552 §5.

Feed-forward dynamic humans (Forge4D)

Card: Forge4D: Feed-Forward 4D Human Reconstruction and Interpolation from Uncalibrated Sparse-view Videos.

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 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 2509.24209 §3.2 2509.24209 §4.1. Without the gauge, static PSNR falls to 13.29 2509.24209 tab. 7.
• Temporal state. A learnable state token carries information from earlier frames, so all frames are not attended to at once 2509.24209 §3.3. Without it, novel-time PSNR falls from 29.04 to 28.56 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 2509.24209 §3.4 2509.24209 eq. 5 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 2509.24209 §3.4 2509.24209 eq. 6 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 2509.24209 tab. 1. Novel time and view with eight input frames gives PSNR 29.04 against 18.03 for L4GM 2509.24209 tab. 2. A fusion ablation gives flicker 0.54 against 0.94 without fusion 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 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 2509.24209 tab. 9. Dense motion is only checked on a synthetic set with 11 identities 2509.24209 app. B 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.

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 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 2605.08713 §4.2.
• Planner teacher. A Reeds-Shepp planner supplies behaviour cloning. Its probability falls linearly to zero over 8,000 epochs 2605.08713 §4.2 2605.08713 §5.3.
• Reported results (author-reported). Simulated parking success 83.5% on standard slots and 70.0% on mechanical slots 2605.08713 tab. 1. Real vehicle success is 55 to 85% across five scenarios 2605.08713 tab. 4.
• Cost. About one hour to build the scene for an underground lot, and 53 FPS in simulation 2605.08713 tab. 3.
• Limits. Generalisation to unseen outdoor scenes and to dynamic obstacles is not established, and there is no formal safety guarantee 2605.08713 §6.

Text-to-3D generation (GSGEN)

Card: Text-to-3D using Gaussian Splatting.

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 2309.16585 §4.1 2309.16585 §4.3 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 2309.16585 eq. 3. The weights are 0.1 for the 2D term and 0.01 for the 3D term 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 2309.16585 §4.2 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 2309.16585 §5.2 2309.16585 fig. 2 2309.16585 fig. 5. About 40 minutes per asset on one RTX 3090, which the paper calls on par with Magic3D and Fantasia3D 2309.16585 app. A 2309.16585 §5.2.
• Cost. About 1e5 to 1e6 Gaussians after densification 2309.16585 app. A.
• Limits. The paper says the Janus problem is reduced, not removed, and complex scene descriptions fail 2309.16585 §6 2309.16585 app. C. Densification is sensitive to the split threshold: a small value over-densifies and a large one over-smooths 2309.16585 §5.3.

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

Card: Hierarchical 3DGS.

Keeps the splat renderer and adds a tree over the Gaussians. Distant regions draw merged parents and near regions draw their children 2406.12080 §4.1 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 2406.12080 eq. 3 2406.12080 eq. 4 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 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 2406.12080 eq. 10 2406.12080 eq. 12 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 2406.12080 §6.1 2406.12080 app. C.2 2406.12080 §6.3. Chunks are 50 by 50 m for walking captures and 100 by 100 m for vehicle captures 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 2406.12080 tab. 2. Full scenes average 30 FPS or more at the finest target and about 60 FPS at the middle one 2406.12080 §8.2.
• Cost. About 400 bytes per Gaussian in the implementation, 69% more than 3DGS. Consolidated scenes are 6 to 88 GB 2406.12080 §8.2 2406.12080 §8.1.
• Limits. Pose estimation for each chunk takes 30 minutes to 5 hours per chunk 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.

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 2607.05543 §3 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 2607.05543 §3.1 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 λ 2607.05543 §3.2 2607.05543 eq. 4 2607.05543 app. B.3.
• Occupancy. Log-odds rise on surface matches and fall where free space is seen. Occlusion does not lower occupancy 2607.05543 §3.2 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 2607.05543 eq. 7 2607.05543 eq. 8 2607.05543 app. B.5.
• Hierarchy. Memory is split into submaps and a connectivity graph, and nearby elements are merged periodically 2607.05543 §3.3 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 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 2607.05543 tab. 5.
• Limits. Most training and fusion values are not stated, so an implementer must choose and tune them 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 2607.05543 app. C.1.

When to use which

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 2312.13150 §3.1. Labelling variants such as GS3LAM, Gaussian Grouping and Feature 3DGS also blend a per-Gaussian vector with the same weights 2603.27781 eq. 7 2312.00732 eq. 1 2312.03203 eq. 3.

# 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 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 2403.17888 tab. 2 2403.17888 tab. 4.
• Depth for the normal target. The paper uses the median depth point 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 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 2406.17074 tab. 1 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 2312.00732 tab. 1, and Feature 3DGS's base 3DGS row is 36.13 PSNR on Replica 2312.03203 tab. 1. SparseGS reports 17.49 PSNR for 3DGS with 12 input views on Mip-NeRF 360 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) 2312.00206 §4.3 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 2312.13150 §4.2 2312.13150 tab. 7. On CO3D the text says 1,000 times faster, and the Figure 4 caption says 100 times 2312.13150 §4.1.1 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) 2603.27781 §4.5 2603.27781 tab. 5. The text also says five ScanNet subsets where the tables show six 2603.27781 §4.1 2603.27781 tab. 1.
• SplaTAM keyframe choice. The SplaTAM text takes the earlier keyframes with the highest overlap with the current frame 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 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 2508.15376 tab. 1. The nighttime paper gives 30.1 and 31.0 on its own Waymo set, which is 11 night scenes 2602.13549 tab. 1 2602.13549 §4.1. DriveSplat uses 12 sequences 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 2508.15376 §4.3. Its table has OmniRe at SSIM 0.939 against 0.937 for DriveSplat 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 2508.15376 §4.3 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 2603.07552 §3.1 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 2312.00451 tab. 1. SparseGS gives 16.94 for 3DGS on LLFF 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 2312.00451 §3.3. The appendix links the MiDaS v2 model and says it outputs inverse depth 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 2312.00451 eq. 7.
• Forge4D hardware. Section 4.3 gives an H200 for the speed table 2509.24209 §4.3. The appendix comparison says H20 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 2509.24209 app. C 2509.24209 tab. 1 2509.24209 tab. 2.
• Two-view and dense-view numbers. MVSplat's RealEstate10K results use two context views at 256 × 256 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 2605.08713 tab. 3 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 2412.02140 §3.1 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 2502.12138 §4.2. On ETH3D, MASt3R has the lower overall error, 0.3522 against 0.4978 for FLARE 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 2412.02140 §4.1 2412.02140 tab. 3.

Papers

• A Survey on 3D Gaussian Splatting: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: Point-E initialisation and 2D and 3D score distillation over Gaussians, with compactness-based densification, for text-to-3D objects.
• Hierarchical 3DGS: 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: 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: 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: viewpoint tokens from Plücker rays, refined over twelve cross- and self-attention layers, predict Gaussians from posed images in one pass.