In December 2023, feed-forward 3DGS models turned 64×64 renders of ShapeNet objects into 3D. Two years later, they turn a single photograph into a metric-scale scene in under a second. In this post, we cover how the field got there, stage by stage.
In the original 3D Gaussian Splatting, obtaining a scene is an optimization problem. You collect hundreds of photographs, run COLMAP to recover the cameras and a sparse point cloud, then fit a few million Gaussians to that one scene for several minutes on a good GPU. For the next scene you start again from scratch. The result renders beautifully in real time, but the reconstruction itself is a fitting procedure, not a model: nothing it learned carries over to the next scene.
Feed-forward 3DGS asks the opposite question. If a network has already seen a hundred thousand scenes, can it look at photographs it has never seen and emit the Gaussians directly — no test-time optimization, no COLMAP, no per-scene loop? Between December 2023 and December 2025 the answer went from "yes, for a toy problem" to "yes, for a photograph of your living room, at metric scale, in under a second."
This article covers that progression through the major papers that drove it. We split it into six stages, ranging from a proof of concept on synthetic objects (stage 01) to production-ready models (stage 06). Each stage relaxes an assumption made by the previous one, and the limitation listed at the foot of each stage motivates the next.
December 2023 — May 2024
Single objects rendered at 64×64 or 128×128, alone on a clean background. The question being answered: can a neural network produce a usable 3D representation in a single forward pass?
Splatter Image · A Pixel Is Worth More Than One 3D Gaussians
Limitation: these models do not transfer to photographs of real scenes.
December 2023 — April 2024
Real interiors at 256×256, with camera poses supplied by COLMAP. Two families of methods emerge: regressing depth directly from image features, and estimating depth by matching features across views.
pixelSplat · latentSplat · MVSplat · GS-LRM
Limitation: training and evaluation are confined to a single dataset, and depth estimates are unreliable wherever cross-view matching fails.
May 2024 — October 2024
Models stop learning geometry from the reconstruction task alone and build on monocular depth networks pretrained on much larger datasets. Reconstructing a real scene from a single image, and fusing long capture sequences, both become tractable.
Flash3D · FreeSplat · DepthSplat
Limitation: the model still requires camera poses as input.
December 2023 — August 2025
Camera poses stop being an input: the model estimates them. By the end of the stage, a single network predicts the 3D reconstruction, the camera extrinsics and the intrinsics directly from photographs.
DUSt3R & MASt3R · Splatt3R · NoPoSplat · SPFSplat
Limitation: each method relies on an architecture designed specifically for this task and trained only on reconstruction data.
March 2025 — November 2025
A single transformer, trained on large amounts of 3D data across several geometric tasks, matches and then surpasses the specialized pipelines. Gaussian prediction becomes a lightweight head fine-tuned on top of this backbone.
VGGT · AnySplat · Depth Anything 3
Limitation: the number of Gaussians is still tied to the input pixel grid, which produces millions of redundant primitives.
September 2025 — December 2025
Research shifts to efficiency and output quality: fewer Gaussians, sharper renderings, metric scale, low latency. By late 2025, a single photograph becomes a metric-scale scene in under a second, rendering at over 100 fps.
Remaining challenges: generalization beyond the training distribution, and evaluation protocols that have not caught up with the models.
One remark before the details: feed-forward 3DGS is not only single-image reconstruction. The single-image setting is arguably the most under-constrained one — the depth of every pixel is ambiguous, and half of the scene is occluded — which is why stage 01 attempts it only on synthetic objects, and why solving it on real scenes at metric scale comes last. Other methods take two views, several views, or long video sequences as input. In those settings, the appeal of a feed-forward model is not resolving ambiguity, which the additional views largely do; it is instant reconstruction, and the priors learned from training across many scenes.
Every question that later defines this field — where the geometry comes from, where the Gaussians live, what supervision is available — appears here first, in miniature, under the most controlled conditions available: rendered objects, clean backgrounds, and viewpoints supplied by the dataset.
A U-Net takes one image and outputs a tensor of the same spatial dimensions carrying twelve channels per pixel — opacity, a three-dimensional offset, depth, scale, and a rotation quaternion — plus colour, either three channels for plain RGB or twelve for spherical harmonics up to order one. Each pixel is decoded into exactly one Gaussian. The result is rendered from a novel viewpoint with the standard differentiable rasterizer, compared against a ground-truth image, and backpropagated. That is the whole method.
The contribution is the reframing rather than the machinery: predicting 3D becomes an image-to-image problem, so the entire toolbox of 2D architecture design applies without modification. It is also fast — reconstruction at 38 frames per second, rendering at 588, roughly a thousand times faster than pixelNeRF, the generalizable NeRF it is measured against.
The limits follow from the same choice. One Gaussian per pixel can represent only the first visible surface, so anything occluded has nowhere to be stored. And the evaluation never leaves the laboratory: 64×64 renders for multi-category ShapeNet, 128×128 for single-class cars and chairs, objects centred on empty backgrounds. Nothing about this configuration resembles a photograph — which is not a criticism, because establishing that the forward pass works at all was the point.
A direct response to the assumption above. With exactly one Gaussian per pixel, a model can only represent the surface visible in the image: whatever lies behind it — the back of the object, an occluded wall — has no Gaussian available to represent it. The fix is to predict several Gaussians per pixel instead of one. The first Gaussian covers the visible surface, exactly as in Splatter Image; a small additional network then predicts three more Gaussians for that pixel, which can be placed behind the first to represent what it hides.
The paper is modest in scope, staying on ShapeNet and CO3D. But the question it raises — should the scene's structure or the sensor's pixel grid decide where primitives go? — does not go away. It returns eighteen months later as voxel-aligned prediction, and by then it is one of the central issues in the field.
The move to real data arrives with a fixed experimental protocol that shapes everything in this stage. The dataset is RealEstate10K: 67,477 indoor video sequences taken from YouTube property tours, with camera poses for every frame computed beforehand by structure-from-motion. The task is defined on top of it as follows: the model receives two input frames from a video sequence, downscaled to 256×256, and predicts the 3D scene. Evaluation uses held-out frames of the same sequence: the predicted scene is rendered from the held-out frames' camera viewpoints, and the rendered images are compared with the real ones. Four papers work against this same setup within five months of each other. Because the conditions are fixed, the methods can be compared directly — and their disagreement is about one question: should depth be regressed from image features, or estimated by matching features across the two input views?
The obstacle pixelSplat identifies is not depth estimation as such, but scale. Structure-from-motion reconstructs each training scene only up to an arbitrary scale factor, so a model trained across thousands of scenes cannot learn a consistent notion of distance; it has to read the scale off the camera pair it is given. The mechanism for this is a multi-view epipolar transformer: for a pixel in one image, the corresponding content in the other must lie on a known epipolar line, so features attend along that line, and each sample on it is annotated with its triangulated depth — which is what carries the scene's scale into the features.
The second obstacle is that gradients through 3D Gaussians are local. A primitive placed incorrectly receives almost no useful gradient, because once it sits more than a few standard deviations from where it should be, the rendering loss barely depends on it. Rather than regressing positions directly, pixelSplat predicts a dense probability distribution over depth along each ray, samples three depths per ray from it, places a Gaussian at each, and sets each Gaussian's opacity to the predicted probability of the depth it was sampled at. This reparameterization is what makes the model trainable: geometry improves by reshaping a probability distribution, not by dragging misplaced primitives through space.
It earned a Best Paper Honorable Mention at CVPR 2024 and defined the benchmark everyone still reports against. It is also heavy — 125.4M parameters, roughly 0.1 seconds per pair — and its geometry is weak: viewed from viewpoints far from the input cameras, the reconstruction is a cloud of floating Gaussians, and the authors need an extra 50,000 steps of depth-regularized finetuning before the underlying structure is presentable. This gap between image quality and geometric quality matters for what follows.
latentSplat addresses a different limitation: where neither input view observed a region, the information does not exist, and a model trained with a reconstruction loss will regress to the mean and produce blur there. Its response is to predict variational feature Gaussians: the geometry stays deterministic, but each Gaussian carries a distribution over its feature vector rather than a fixed colour. Rendering produces a feature map, and a lightweight VAE decoder trained with adversarial losses turns it into an image, synthesizing plausible detail exactly where the inputs were uninformative. It is the first paper in this line to treat part of the problem as generation rather than reconstruction — a position that later becomes standard.
MVSplat settles the regression-versus-matching question with the cleanest head-to-head experiment in this literature (I compare the two methods in depth in pixelSplat vs MVSplat). Rather than asking a network to predict depth from features, it estimates depth by matching. It builds a plane-sweep cost volume: for every pixel, it hypothesizes 128 candidate depths, and for each candidate it checks how well the two views agree — the other view's features are warped into the current view using the known cameras, assuming that candidate depth, and correlated with the local features. High correlation means both views see the same content at that depth, which is evidence of a surface. A lightweight 2D U-Net with cross-view attention refines the volume, a softmax across the depth dimension converts it to weights, and the weighted average of the candidates is the depth. Unprojecting those depths gives the Gaussian centres.
One detail is worth singling out: opacity is taken from the maximum of that softmax. Confidence that a surface was matched becomes confidence that a Gaussian should be visible, so geometry and appearance stop being independent predictions.
The results are unambiguous. Against pixelSplat on RealEstate10K: 26.39 versus 25.89 PSNR, 12.0M parameters versus 125.4M, 0.044 seconds versus 0.104, and trained with a photometric loss alone — no depth finetuning stage, yet visibly better geometry. Ablating the cost volume drops PSNR from 26.12 to 22.83. Most convincingly, the appendix installs MVSplat's cost volume inside pixelSplat's own architecture, replacing its probabilistic depth branch, and reports 25.89 → 26.63. The mechanism transfers between architectures, which is the strongest evidence available that the cost volume, not the surrounding network, was doing the work.
A distinction that matters for the rest of this article: the cost volume changed how depth is computed, not how the scene is parameterized. The volume is a per-view structure, indexed by pixel and depth candidate, and the softmax collapses it back to one depth per pixel. In the paper's own words, Gaussian parameters are predicted "in a pixel-aligned manner, and thus the total number of 3D Gaussians is H × W × K for K input images." Matching and pixel alignment are independent choices — which is why, eighteen months later, VolSplat can keep the first and discard the second.
The opposing hypothesis, published a month later. GS-LRM cuts images into 8×8 patches, passes them through a plain 24-layer transformer of roughly 300M parameters, and maps the output tokens back to the pixel grid, one Gaussian per pixel. No cost volume, no epipolar constraint, no geometric inductive bias of any kind — the paper states this explicitly and treats it as the contribution. It trains an object model on Objaverse taking four views at 512×512 and a scene model on RealEstate10K taking two views at 256×256, each reconstructing in 0.23 seconds on a single A100. The training cost puts the comparison in context: 64 A100s for three days.
Set beside MVSplat, this is the real argument of 2024. Is a matching prior a durable insight about the structure of the problem, or a workaround for insufficient compute? Twelve million parameters beating a model ten times its size argues for structure; GS-LRM's scaling behaviour argues that structure is what you build when you cannot afford data. Both approaches developed in parallel over the following year, and stage 05 settles the question — in favour of large general models.
Everything in stage 02 learns geometry from the reconstruction task itself, on one dataset — which is why it fails wherever that dataset offered no evidence: textureless walls that defeat matching, regions seen by only one view, scenes that look nothing like a property tour. The papers in this stage import their geometric knowledge instead, from monocular depth networks pretrained on much larger and more varied data, and use the reconstruction objective only to adapt it. It is the first appearance of the pattern that eventually takes over the field.
Single-image reconstruction, as in stage 01, but of a real scene rather than an isolated object — made possible by not learning geometry from scratch. Flash3D builds on a frozen UniDepth model, frozen to the point that its depth maps are pre-extracted before training begins, and predicts Gaussian parameters relative to the geometry that network already supplies.
It also drops the one-Gaussian-per-pixel constraint, for the same reason as the hierarchical work in stage 01: it predicts two Gaussians per pixel, the second constrained to lie behind the first, so that the model can represent the surfaces the visible one hides. Trained on RealEstate10K on a single GPU in about a day, it transfers to NYU and KITTI with no finetuning — a generalization result no stage 02 model could produce, obtained by importing the robustness rather than learning it.
FreeSplat extends the setting in the other direction: long input sequences instead of two frames. It keeps a cost volume but makes it local, built only over nearby views, and then merges the per-view predictions with a learned fusion step that removes duplicate Gaussians where several views observe the same surface. It reconstructs whole indoor scenes from sequences of dozens of frames on ScanNet and transfers zero-shot to Replica; its "free view range" refers to rendering, meaning viewpoints far from any input camera rather than interpolation between two of them.
That fusion step deserves more attention than the paper gives it: it is the first departure from the rule that the input images fix the number of Gaussians, since two frames observing the same wall no longer contribute two independent copies of it.
The synthesis of stages 02 and 03, and the paper most often missing from accounts of this field. DepthSplat combines pretrained monocular depth features with a multi-view cost volume, so the model has something to fall back on precisely where correspondence breaks down, without giving up the metric precision that matching provides. It reconstructs from twelve input views in 0.6 seconds.
Its second claim is the more consequential one: the relationship runs both ways, because splatting can serve as an unsupervised training objective for depth models — rendering quality is a supervision signal obtainable from raw multi-view video with no depth ground truth at all. Both of the works that close this article, ReSplat and VolSplat, build directly on its design.
Every multi-view method so far assumes the cameras are known, which in practice means running structure-from-motion before the "single forward pass" begins. That step takes minutes to hours, needs substantial overlap between images, and fails on low-texture scenes. This stage removes it. Note that its founding paper appeared in December 2023, alongside the earliest work above — these lines of research developed in parallel, not in sequence.
DUSt3R takes two uncalibrated images — no poses, and not even focal lengths — and regresses pointmaps: a 3D point for every pixel of both images, with both maps expressed in the coordinate frame of the first image, alongside per-pixel confidence. Focal lengths, relative pose and absolute cameras are recovered afterwards from the pointmaps by small optimizations. Camera parameters have stopped being an input and become an output of reconstruction, and the rest of this stage is built on that inversion.
One caveat is usually lost in summaries: the network operates on pairs. Collections of more than two images are stitched by a global alignment optimization over the pairwise pointmaps, which takes seconds on a GPU rather than the minutes of a bundle adjustment, but is not a single forward pass. MASt3R then adds a local-feature head trained with an InfoNCE matching loss and a fast reciprocal matching scheme, turning DUSt3R into a matching and localization model. Neither paper predicts Gaussians, but every pose-free splatting method below builds on them.
Splatt3R combines the two preceding ideas: freeze MASt3R entirely, train only a Gaussian prediction head on its pointmaps, and supervise with a rendering loss — MSE plus LPIPS, computed only on regions that are visible from both input views. The result is pose-free feed-forward splatting from an uncalibrated pair, trained on ScanNet++, running at about 4 frames per second on 512×512 inputs with real-time rendering afterwards.
It is worth being precise about what "no depth supervision" means here. Splatt3R never sees depth — but the MASt3R beneath it was pretrained on ground-truth pointmaps. The supervision has moved upstream, not disappeared. That is an accurate description of most of what follows in this field.
The result that turned pose-free prediction from a concession into the default. NoPoSplat predicts the Gaussians for all input views directly in a single canonical space, anchored to the first view's camera frame, so there is no per-view prediction that must be transformed into a shared frame afterwards.
This design choice is the paper's central argument, and it is frequently misreported. Pose-conditioned methods predict Gaussians in each view's local frame and warp them into a common one, and this transform-then-fuse step degrades when views barely overlap: small errors in the transformation appear as seams and duplicated geometry. Predicting everything in one frame from the outset removes that failure mode. The numbers support the argument — on RealEstate10K, NoPoSplat reaches 25.03 PSNR against MVSplat's 23.98 and pixelSplat's 23.85 while both baselines are supplied with ground-truth poses, and the margin grows to 2.2 dB on the subset of test pairs where the two views barely overlap — exactly where the transform-then-fuse approach is weakest.
One qualification: this is pose-free, not calibration-free. NoPoSplat still requires camera intrinsics, injected as an embedding, on the reasonable argument that modern devices report them. It was an oral at ICLR 2025.
SPFSplat removes the last requirement. It uses no ground-truth poses at training time or at inference: Gaussians and cameras are predicted jointly from a shared backbone in canonical space, supervised by a rendering loss on target views rendered with the model's own predicted poses, plus a reprojection term. And unlike NoPoSplat, it keeps outperforming prior work even when the camera intrinsics are not provided. From this point on, a single network predicts the reconstruction, the extrinsics and the intrinsics, directly from photographs. It was a highlight at ICCV 2025.
Four stages of progress produced four task-specific architectures: an epipolar transformer, a cost volume, a depth-feature hybrid, a pointmap regressor. This stage replaces them all with a different design: one large model, trained on large amounts of 3D data across several geometric tasks, with reconstruction attached as an output head.
VGGT is a single large transformer that alternates frame-wise self-attention, within each image, with global self-attention across all of them. From one view, a few, or hundreds, it predicts camera parameters, depth maps, point maps and 3D point tracks together in a single forward pass — no cost volumes, no epipolar constraints, and none of the iterative post-optimization DUSt3R requires, only lightweight prediction heads on a plain backbone. On an H100 it processes one frame in 0.04 seconds and fifty frames in about a second.
It won Best Paper at CVPR 2025, and it marks the turning point for this field (I cover the architecture and results in detail in VGGT Explained): two years of hand-built geometric structure proved reproducible, and then beatable, by a general architecture trained on enough data. Note that VGGT itself outputs no Gaussians — its view-synthesis experiment regresses pixels directly, with no 3D representation at all. That is exactly what lets it serve as a backbone for everything that follows.
AnySplat, published ten weeks later, attaches the Gaussian head. It accepts an arbitrary number of uncalibrated views — demonstrated from two to sixty-four — and predicts Gaussians together with intrinsics and extrinsics in one pass. A differentiable voxelization step clusters per-pixel Gaussian centres into voxels, removing 30 to 70 percent of redundant primitives so that cost stops growing linearly with view count.
The training is the more significant part: there is no structure-from-motion or multi-view-stereo ground truth anywhere in it. A pretrained VGGT acts as teacher, supplying pseudo-labels for geometry and cameras alongside photometric and consistency losses. Supervision now comes from another network. Every constraint that defined stage 02 — two views, known cameras, one benchmark — is gone.
DA3 makes the strongest case for architectural minimalism. A single plain transformer — a vanilla DINO encoder — "is sufficient as a backbone without architectural specialization", and a single depth-ray prediction target "obviates the need for complex multi-task learning". It accepts any number of images, with or without poses, and with one image it reduces to monocular depth estimation. On the authors' visual-geometry benchmark it surpasses VGGT by an average of 44.3 percent on camera pose accuracy and 25.1 percent on geometric accuracy (revised upward from the 35.7 and 23.6 percent in the paper's first version).
For this article, the important part is what sits on top: a standard dense-prediction head (DPT) that outputs pixel-aligned Gaussian parameters, trained on the frozen geometry backbone — with the authors reporting that this outperforms the specialized task-specific models (I cover the architecture and results in detail in Depth Anything 3 Explained). Consider what that means for stages 01 through 04: feed-forward 3DGS is no longer an architecture you design. It is a decoder you attach to a geometry backbone.
With camera estimation handled and geometry supplied by pretrained backbones, the remaining gap between these models and practical use is efficiency and output quality: too many primitives, renderings that are too soft, no absolute scale, and latency too high for interactive applications. The last three papers address exactly these.
VolSplat identifies three defects of pixel-aligned prediction: the number of Gaussians is fixed at H × W × N and therefore determined by however many views were supplied; primitive density follows the cameras rather than the scene, so Gaussians concentrate where the cameras looked instead of where the scene is complex; and the output inherits alignment errors from 2D feature matching wherever there is occlusion or low texture.
Its answer is to predict on a voxel grid: Gaussians are placed where the scene has structure, with density adapted to 3D complexity and decoupled from input resolution. Built on Depth Anything V2 features with a sparse 3D U-Net, it keeps the plane-sweep cost volume it inherits from DepthSplat and changes only where the primitives live — a clean demonstration that matching and pixel alignment were always separate decisions. It reports 31.30 PSNR on RealEstate10K against DepthSplat's 27.47, and 28.41 on ScanNet, and appears at ECCV 2026. It is also, in substance, the answer to the question A Pixel Is Worth More Than One 3D Gaussians asked back in stage 01.
A feed-forward prediction is never perfect: some Gaussians end up in slightly wrong places, with slightly wrong colours. In classic per-scene 3DGS, such errors are fixed by optimization — render the Gaussians, compare against the input images, backpropagate, update, and repeat for thousands of steps. ReSplat replaces that optimization with a learned refinement. It starts from a feed-forward prediction, renders it back into the input views, and compares the renderings with the actual input images; the mismatch tells it where the prediction is wrong. A refinement network takes that error signal, together with the current Gaussian parameters, and directly outputs improved parameters. Applying this refinement two or three times is enough. One implementation detail: the renderings and images are compared in the feature space of a pretrained ResNet-18 rather than pixel by pixel, which gives a more informative error signal.
The crucial difference from per-scene optimization is that no gradients are computed at test time. During training, the refinement network learned what correction to make for a given error; at inference it simply applies that knowledge, so refining a new scene takes a few forward passes instead of thousands of optimization steps. The results justify the extra passes: starting from a compact DepthSplat-style prediction, ReSplat reaches 26.82 PSNR on eight-view DL3DV with 246,000 Gaussians, where DepthSplat reaches 24.17 with 3.9 million — higher quality with sixteen times fewer Gaussians. The lesson: refinement was never the expensive part of 3DGS. Starting from scratch on every scene, with a generic optimizer, was.
Apple's single-image model shows how far the field has come (I cover the architecture, training tricks and licensing in detail in Apple SHARP Explained). One photograph in; a metric-scale 3D Gaussian scene out, in under a second on an A100; rendering above 100 frames per second afterwards, at roughly 1.2 million Gaussians from a 1536×1536 input.
The mechanism deserves attention, because the name might suggest a generative model and it is not one. SHARP is regression: a largely frozen Depth Pro backbone, a small depth-adjustment U-Net, and a decoder predicting corrections to fourteen Gaussian attributes, with two Gaussians per pixel — the same trick as Flash3D — so that regions hidden in the input can still be filled. The sharpness comes from operating at high resolution end to end and from the loss design, which pairs colour losses on input and novel views with perceptual and Gram terms that keep hallucinated regions plausible instead of blurred. Evaluated zero-shot, it reduces LPIPS by 25 to 34 percent and DISTS by 21 to 43 percent against the strongest prior methods, Flash3D among them. Code and weights are public, under Apple's own licence rather than a permissive one.
Compare it with Splatter Image to measure the two years of progress. The same input — one image. In December 2023: a 64×64 synthetic car on an empty background, at arbitrary scale. In December 2025: a megapixel photograph of a real room, at metric scale, reconstructed in under a second and rendered in real time.
| December 2023 | December 2025 | |
|---|---|---|
| Data | Synthetic object renders; one indoor video corpus | Diverse real captures at megapixel resolution |
| Camera poses | Required, from structure-from-motion | Predicted by the model |
| Camera intrinsics | Required throughout | Optional (SPFSplat, AnySplat) |
| Source of geometry | Learned from the reconstruction task alone | A pretrained geometry foundation model |
| Gaussian placement | Fixed at H × W × N by the input images | Adaptive, following scene structure |
| Scale | Arbitrary, per scene | Metric |
| Reconstruction time | ~0.1 s per posed pair | < 1 s from a single photograph |
| Supervision | Photometric, plus depth-regularized finetuning | Photometric, or distilled from another model |
Training data. A large share of this literature trains on RealEstate10K — 67,477 sequences of indoor property-tour video from a single source. Models trained on it perform markedly better on similar indoor footage than on anything else, and the results that generalize best in 2025 belong to models trained across many datasets, or distilled from one that was. Scaling the diversity of training data, not just its volume, is the clearest open direction.
Evaluation. The standard comparison is still two views at 256×256, while the models being compared accept dozens of views at high resolution, so cross-dataset transfer has become more informative than in-distribution PSNR. Pose-free methods complicate it further: they cannot be scored against pose-conditioned baselines without first aligning their predicted cameras to the ground-truth ones, which has made the evaluation protocol itself a research question.
Metrics that ignore geometry. PSNR rewards blur, LPIPS tracks perception better, and neither says whether the underlying 3D structure is coherent. A model can post strong numbers while its Gaussians form a cloud of floaters — exactly the gap MVSplat exposed in pixelSplat. Assume that gap is present whenever a paper shows renders and never shows the point cloud.
Start with Splatter Image. Its full pipeline fits in a few hundred lines, and building it teaches the one step nearly every later paper reuses: decoding network features into valid Gaussian parameters. My from-scratch walkthrough is here.
Then make a single change: replace the depth prediction with a plane-sweep cost volume over two views. That substitution is, in essence, MVSplat's contribution — and watching your geometry sharpen while your parameter count falls is the most direct way to see why stage 02 resolved the way it did. If you want to know what the rasterizer is doing underneath while it trains, I cover that in implementing a custom backward pass for 3DGS.
Nearly every method above renders through the same differentiable rasterizer. My 3D Gaussian Splatting Course builds that pipeline from first principles in PyTorch only — no CUDA, no C++ — covering initialization, rasterization, backward passes and training loops, so papers like these become things you can implement rather than things you read about.
Explore the Course →The direction is not in serious doubt. Reconstruction is being absorbed into general geometry models, and the work that remains is what you attach to them and how you place what they produce. The assumption that organized 2024 — every Gaussian tied to an input pixel — is giving way to representations that follow the scene rather than the sensor. And the open problems are no longer architectural: they are data diversity, and evaluation that measures geometry rather than rendered pixels.
There is a telling symmetry in who is doing the work. MVSplat's first author leads VolSplat; its second author leads DepthSplat and ReSplat. The researchers who built the strongest pixel-aligned models are the ones now moving beyond pixel alignment, which is usually what a healthy field looks like.
So when a 2026 paper claims a new state of the art, three questions separate an advance from a benchmark result. What does it assume about the cameras — poses, intrinsics, or neither? What does its geometry look like from outside the input frustum? And does it hold up on scenes that resemble nothing in its training set?
A final note on scope. World models — systems such as Genie that also turn a single image into an environment you can move through — are a different line of work, and not a competing answer to this problem. They generate the next view on the fly with a video model conditioned on the user's movement: there is no explicit 3D representation underneath, no geometry to export, and no guarantee that the scene is unchanged when a viewpoint is revisited. Feed-forward 3DGS reconstructs an explicit scene; a world model generates views as you go. This article covers only the former; I take up world models in a separate article.
I share practical posts on 3DGS, NeRF, PyTorch implementations, research breakdowns, and the engineering details that usually get skipped.
Subscribe →At Qubit Analytics, we help companies put 3D Gaussian Splatting to work — classic per-scene 3DGS, feed-forward 3DGS, and the 3D foundation models covered on this page. We integrate these techniques into products, build custom reconstruction pipelines, and turn recent research into working prototypes.
For consulting inquiries:
contact@qubitanalytics.be