---
title: 'ViewSplat: Feed-forward 3D Gaussian Splatting'
url: https://www.emergentmind.com/topics/viewsplat
type: topic
---

# ViewSplat: Feed-forward 3D Gaussian Splatting

ViewSplat denotes feed-forward 3D Gaussian splatting architectures for novel-view synthesis, and the name has been used in two distinct but related senses in the recent literature. In one consolidated description, “ViewSplat” refers to the same three-stage, coarse-to-fine architecture as HiSplat, a hierarchical 3D Gaussian splatting framework for generalizable sparse-view reconstruction that performs novel view synthesis using only two-view reference images [2410.06245]. In a later paper, ViewSplat denotes a view-adaptive 3D Gaussian splatting network for novel view synthesis from unposed images, in which canonical Gaussians are refined on-the-fly through target-view-conditioned residual updates produced by pixel-wise dynamic MLPs [2603.25265]. In both usages, the underlying representation is a set of anisotropic 3D Gaussians rendered by a 3DGS rasterizer, but the mechanisms for improving fidelity differ: one emphasizes hierarchical coarse-to-fine correction, whereas the other emphasizes view-adaptive dynamic splatting.

## 1. Scope of the designation

A consolidated description tied to HiSplat states that “ViewSplat” refers to the same three-stage, coarse-to-fine architecture, with “ViewSplat” used as the name of a hierarchical 3D-Gaussian-splatting pipeline for generalizable two-view reconstruction. The 2026 paper titled “ViewSplat: View-Adaptive Dynamic Gaussian Splatting for Feed-Forward Synthesis” uses the same term for a different pipeline centered on dynamic, target-view-conditioned residual refinement [2410.06245].

| Designation | Input regime | Distinguishing mechanism |
|---|---|---|
| ViewSplat as HiSplat | two-view reference images | hierarchical 3D Gaussians via a coarse-to-fine strategy |
| ViewSplat (2026) | \(N\) unposed images | view-adaptive dynamic splatting with pixel-wise dynamic MLPs |

This dual usage is significant because it prevents a common conflation. The hierarchical variant is organized around multi-stage Gaussian generation and inter-scale correction. The dynamic variant is organized around canonical Gaussians plus target-view residual offsets for 3D position, scale, rotation, opacity, and color. A plausible implication is that “ViewSplat” should be interpreted by publication context rather than by name alone.

## 2. Gaussian formulation and image formation

In the hierarchical formulation, each Gaussian \(j\) is parameterized by \(\mu_j \in \mathbb{R}^3\), \(\Sigma_j \in \mathbb{R}^{3\times 3}\), \(c_j \in \mathbb{R}^3\), and \(\alpha_j \in [0,1]\). When projecting to an image, the contribution of Gaussian \(j\) to pixel \(p\) is

$$
G_j(p) = \alpha_j \cdot c_j \cdot N_2(u_p; \Pi(\mu_j), \Pi \Sigma_j \Pi^T + \sigma_{\text{image}}^2 I_2),
$$

where \(\Pi\) is the \(3\text{D}\to 2\text{D}\) projection and \(u_p\) is the pixel coordinate. Feed-forward prediction proceeds from a pixel-aligned feature \(F_i^{GS}(u)\), from which a small CNN head regresses the center via un-projecting the predicted depth \(D_i(u)\) along the camera ray \(r(u)\), opacity through a sigmoid head, covariance through predicted positive axis-scales, and color as a small vector or SH coefficients [2410.06245].

In the dynamic formulation, a single anisotropic 3D Gaussian primitive is

$$
G(x) = w \exp\!\bigl(-\tfrac12 (x-\mu)^T \Sigma^{-1}(x-\mu)\bigr),
$$

with \(\Sigma = R\,\mathrm{diag}(s \odot s)\,R^T\), where \(s \in \mathbb{R}^3\) are scale factors and \(R\) is derived from a rotation quaternion \(r \in \mathbb{R}^4\). In practice the representation stores \(\mu\), \(s\), \(r\), opacity \(\alpha\), and color as \(L\) spherical-harmonic coefficients \(c \in \mathbb{R}^L\). Rendering is expressed as

$$
\hat I^t = \mathcal{R}(P^{t\to 1}, \{\hat{\mathcal{G}}^{v\to 1|t}\}_{v,j}),
$$

where a 3DGS rasterizer projects each anisotropic Gaussian into the target view, splats its elliptical footprint into screen space, and accumulates color with alpha compositing in front-to-back order [2603.25265].

The shared formalism is the use of anisotropic Gaussians as explicit scene primitives. The divergence lies in how those primitives are predicted and corrected: multi-scale staged prediction in the hierarchical system, and target-view-conditioned residual adaptation in the dynamic system.

## 3. Hierarchical coarse-to-fine reconstruction

The hierarchical ViewSplat builds three stages \(i=1,2,3\), ordered low-to-high resolution and coarse-to-fine. Stage 1 operates at input resolution \(H/4 \times W/4\) and uses an MVS-style cost-volume stereo block. Given cross-view features \(F_1\) from a U-Net+Transformer backbone, the method sweeps \(R\) depth planes, warps other views into view \(i\), builds a cost volume, predicts depth by softmax over the cost-volume slice, and then forms \(F_1^{GS}(u)\) from a small CNN on \([F_1, F_{cv}]\). These Gaussians capture the scene “skeleton,” including large-scale structure such as blocks, walls, and major surfaces [2410.06245].

Stages 2 and 3 operate at higher spatial resolutions \(H/2 \times W/2\) and \(H \times W\). Rather than predicting independently, each stage \(i>1\) re-uses stage \(i-1\): it renders the previous-stage Gaussians back into the input views, computes an error map

$$
E_{i-1}(u) = |\hat I_{i-1}^{ref}(u) - I_{in}^{ref}(u)|,
$$

and applies an Error Aware Module (EAM) that ingests \([E_{i-1}, F_i]\) to predict a small residual depth offset \(\Delta D_i(u)\) and \(F_i^{GS}(u)\). The fractional offset is

$$
\Delta D_i(u) = \bigl(2\alpha_i(u)-1\bigr)\,\eta\,\mathrm{Interp}\bigl(D_{i-1}\bigr)(u),
$$

with \(\eta \ll 1\) and the updated depth given by

$$
D_i(u)=\mathrm{Interp}(D_{i-1})(u)+\Delta D_i(u).
$$

This design localizes regions where coarse Gaussians fail and adds corrective, smaller Gaussians.

Fusion across stages is handled by the Modulating Fusion Module (MFM). For each previous stage \(k<i\), the module concatenates upsampled fine-stage features with previous Gaussian features,

$$
F^{\rm cat}_k(u)=\bigl[\mathrm{Interp}(F_i^{GS})(u)\,\|\,F_k^{GS}(u)\bigr],
$$

computes a gating weight

$$
\xi_k(u)=\mathrm{sigmoid}\bigl(MLP_2\{MLP_1(F^{\rm cat}_k(u))\times E_k(u)\}\bigr),
$$

and updates opacity through \(\alpha_k(u) \leftarrow \alpha_k(u)\cdot \xi_k(u)\). This suppresses old Gaussians in regions where fine Gaussians can better explain the appearance. The resulting architecture explicitly models Gaussians at three resolutions, lets each finer stage attend to and correct the errors of coarser splats, and fuses them through learned opacity gates.

## 4. View-adaptive dynamic splatting

The dynamic ViewSplat takes as input \(N\) unposed images \(\{I^v\}_{v=1..N}\). A shared geometry transformer backbone, such as MASt3R or VGGT, produces multi-view feature tokens. Two Dense Prediction Transformer heads decode these tokens into a “Gaussian center” head that predicts per-pixel 3D centers \(\mu_j^{v\to 1}\) and a “Gaussian parameter” head that predicts per-pixel attributes \(\alpha_j^v\), \(s_j^v\), \(r_j^{v\to 1}\), and \(c_j^{v\to 1}\). These define base canonical Gaussians

$$
G_j^{v\to 1} \coloneqq (\mu_j^{v\to 1}, \alpha_j^v, r_j^{v\to 1}, s_j^v, c_j^{v\to 1}),
$$

aligned to the coordinate frame of view 1. A lightweight pose head regresses each view’s relative extrinsic \(P^{v\to 1} \in \mathbb{R}^{4\times 4}\) in a single forward pass using 6D rotation and 4D translation [2603.25265].

The defining component is the view-dependent head, also DPT-based, which outputs the weights of pixel-wise dynamic MLPs. At render time, each view MLP is instantiated and receives a 4-D target-pose feature \([u_j^v,\ell_j^v]\), where \(u_j^v \in \mathbb{R}^3\) is the unit vector from \(\mu_j\) to the target camera center and \(\ell_j^v = \log(\|d_j^v\|_2+\epsilon)\) is the log-distance. Each view MLP has one hidden layer of \(D=16\) units with ReLU and predicts residuals \(\Delta\mu\), \(\Delta\alpha\), \(\Delta r\), \(\Delta s\), and \(\Delta c\).

These residuals are applied element-wise:

$$
\hat\mu = \mu + \Delta\mu,\qquad
\hat\alpha = \alpha + \Delta\alpha,\qquad
\hat r = \mathrm{normalize}(r + \Delta r),\qquad
\hat s = s + \Delta s,\qquad
\hat c = c + \Delta c.
$$

In compact form,

$$
\hat{\mathcal{G}}^{v\to 1|t} = \mathcal{G}^{v\to 1} \oplus \Delta\mathcal{G}^{v\to 1},
$$

where \(\oplus\) denotes per-component addition with quaternion re-normalization. The paper explicitly frames this as a shift from static primitive regression to view-adaptive dynamic splatting. A common misconception is that the mechanism is limited to view-dependent color modeling; in fact, the residual updates cover 3D position, scale, rotation, opacity, and color.

## 5. Objectives, optimization, and reported performance

The hierarchical ViewSplat supervises the rendered novel-view image from each intermediate fused Gaussian set. With ground-truth novel image \(I^{tar}\) and stage-\(i\) rendering \(\hat I_i^{tar}\), the loss is

$$
\mathcal L = \sum_{i=1}^3 \Bigl[ \lambda_{mse}\,\|\hat I_i^{tar}-I^{tar}\|_2^2 + \lambda_{lpips}\,LPIPS(\hat I_i^{tar},I^{tar})\Bigr],
$$

with default \(\lambda_{mse}=1\) and \(\lambda_{lpips}=0.05\). In the two-view setting on RealEstate10K / ACID, the reported stage-3 performance is PSNR \(=27.21\) versus single-scale MVSplat \(26.39\) \((+0.82)\), SSIM \(=0.881\) versus \(0.869\), and LPIPS \(=0.117\) versus \(0.128\). For zero-shot cross-dataset evaluation, trained on RealEstate10K and tested on Replica, stage 3 reports PSNR \(=27.17\) versus PixelSplat \(23.98\) \((+3.19)\) [2410.06245].

The dynamic ViewSplat uses a total loss

$$
\mathcal{L}_{total} = \mathcal{L}_{render} + \lambda_{reproj}\,\mathcal{L}_{reproj},
$$

where

$$
\mathcal{L}_{render} = \|I^t - \hat I^t\|_2^2 + \lambda_{LPIPS}\,\mathcal{L}_{LPIPS}(I^t,\hat I^t)
$$

and

$$
\mathcal{L}_{reproj}
= \sum_v \sum_j \|p_j^v - \pi(K^v, P^{v\to 1}, \mu_j^{v\to 1})\|_2.
$$

The hyper-parameters are \(\lambda_{LPIPS}=0.05\) and \(\lambda_{reproj}=0.001\). The implementation uses PyTorch with a CUDA-accelerated 3DGS renderer; MASt3R is used for SPFSplat/V2 and VGGT for the V2-L variant; image resolution is \(256\times 256\) and \(224\times 224\) for V2-L; initialization comes from pre-trained SPFSplat or SPFSplatV2 with the view-dependent head zero-initialized; the optimizer is Adam with learning rate \(1\mathrm{e}{-4}\), batch size \(12\), a frozen backbone, and a curriculum that progressively increases inter-view frame distance. On RealEstate10K with SPFSplatV2-L backbone, the reported performance is PSNR \(26.798\) dB, SSIM \(0.870\), and LPIPS \(0.124\), compared with static SPFSplatV2-L at \(25.668/0.855/0.137\), corresponding to \(+1.13\) dB PSNR. Efficiency on one RTX 4090 is reported as inference time \(\sim 0.057\) s \((\approx 17\) FPS) and rendering \(154\) FPS. Trained on RE10K and evaluated zero-shot on ACID and DTU, the method shows consistent \(+0.6\)–\(0.8\) dB gains. Ablations report that the full residual set \((\Delta\mu,\Delta\alpha,\Delta r,s,c)\) is needed and that decoupling \(\mu\) and \(\alpha\) causes collapse [2603.25265].

These two performance profiles reflect different operating assumptions. The hierarchical system emphasizes sparse two-view generalization and cross-dataset behavior under a coarse-to-fine schedule. The dynamic system emphasizes unposed-image synthesis, single-forward-pass pose regression, and residual adaptability at render time.

## 6. Position within the broader Gaussian-splatting landscape

ViewSplat belongs to a broader family of feed-forward Gaussian-splatting systems that differ in supervision, coordinate assumptions, and deployment context. “Cross-View Splatter” is a feed-forward method that predicts pixel-aligned Gaussian splats for outdoor scenes captured at ground level and by satellite, fusing orthorectified satellite views with GPS-tagged ground photos in a unified 3D coordinate frame. Its architecture alternates Attn_frame and Attn_global layers with \(L=12\) bidirectional cross-attention layers \(Attn_{meta}\), and its reported results include Tanks & Temples combined PSNR \(\approx 12.61\) versus ground-only \( \approx 10.65\) in sparse settings [2605.19656].

At the systems level, “SplatBus” is a Gaussian Splatting Viewer Framework via GPU Interprocess Communication. It separates a Gaussian-splatting renderer from one or more interactive viewers, using two TCP channels and a CUDA IPC channel for bulk image data, and is intended to integrate 3DGS outputs with external clients such as Unity, Blender, Unreal Engine, and OpenGL viewers [2601.15431].

This wider context clarifies several points of interpretation. ViewSplat is not synonymous with all feed-forward 3D Gaussian splatting. It is also not uniformly tied to a single camera assumption: the hierarchical variant relies on sparse reference views with an MVS-style cost volume, whereas the dynamic variant explicitly targets unposed images and regresses relative extrinsics in a single forward pass. The term therefore identifies a line of methods centered on feed-forward Gaussian prediction and rasterization, but the concrete realization depends on whether the goal is hierarchical sparse-view reconstruction or view-adaptive dynamic synthesis.

Source: https://www.emergentmind.com/topics/viewsplat