AnchorSplat: Dual 3D Gaussian Splatting Approaches

• AnchorSplat is a dual-approach framework in 3D Gaussian Splatting that employs 3D anchors to locally guide and constrain Gaussian generation.
• The feed-forward method uses external and predicted 3D geometric priors to reconstruct scenes with a fixed Gaussian budget, ensuring depth consistency and view-independence.
• The source-free refinement approach upgrades low-quality 3D assets by locally generating additional Gaussians via a point anchor mechanism to improve structural detail and rendering quality.

AnchorSplat is the name of two distinct 2026 methods in the 3D Gaussian Splatting literature. One, "AnchorSplat: Feed-Forward 3D Gaussian Splatting with 3D Geometric Priors," is a scene-level feed-forward reconstruction framework for novel view synthesis that predicts Gaussians around 3D anchors derived from geometric priors (Zhang et al., 8 Apr 2026). The other, "AnchorSplat: Fast and Structure Consistent Detail Synthesis for Gaussian Splatting," is a source-free, 3D-native refinement network that upgrades an existing low-quality 3DGS asset by generating new local Gaussians around point anchors (Zhu et al., 1 Jul 2026). In both cases, the anchor is a 3D support structure that constrains Gaussian generation locally, but the task definition, supervision regime, and empirical setting differ substantially.

1. Name, scope, and conceptual identity

The two AnchorSplat works occupy different parts of the 3DGS pipeline. The feed-forward version targets direct scene reconstruction from input images. It is motivated by the claim that recent feed-forward Gaussian reconstruction methods are typically pixel-aligned, effectively mapping each image pixel to one Gaussian, so that the number of predicted Gaussians is tied to the image grid,

$N = H \times W \times V,$

with consequent entanglement to image resolution and number of views (Zhang et al., 8 Apr 2026). By contrast, the source-free version assumes that a low-quality 3DGS asset already exists and addresses post hoc enhancement rather than reconstruction from images; it is explicitly framed as 3D super-resolution or asset refinement for Gaussian splatting (Zhu et al., 1 Jul 2026).

The shared vocabulary is nonetheless meaningful. In both cases, anchors define local 3D support regions from which renderable Gaussians are generated. The first method obtains anchors from external or predicted geometry priors and then predicts a small fixed number of Gaussians around each anchor (Zhang et al., 8 Apr 2026). The second treats each input Gaussian primitive as a point anchor and constrains all generated descendants to remain in a bounded local neighborhood around that input primitive (Zhu et al., 1 Jul 2026). This common design choice places both papers within the broader anchor-based 3DGS family, even though one is a reconstruction model and the other a refinement model.

2. AnchorSplat as feed-forward scene-level reconstruction

The feed-forward AnchorSplat formulates scene-level 3D reconstruction and novel view synthesis directly in 3D space rather than through pixel-aligned lifting. Its central representation is an anchor-aligned Gaussian formulation guided by 3D geometric priors, including sparse point clouds, voxels, and RGB-D point clouds (Zhang et al., 8 Apr 2026). In the main pipeline, a pretrained MVS-style model such as MapAnything is used to predict depth maps, camera intrinsics, and poses; those depths are back-projected to 3D and downsampled by farthest point sampling to obtain anchors:

$$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$

The back-projection itself is written as

$$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$

The architecture has three components: an Anchor Predictor, a Gaussian Decoder, and a Gaussian Refiner. A lightweight 2D U-Net encodes per-view RGB, depth, and 6-channel Plücker ray embeddings,

$F_i = E(I_i, D_i, \mathrm{Ray}_i),$

with input dimensionality $3+1+6$ per pixel (Zhang et al., 8 Apr 2026). Multi-view features are then projected onto anchors and pooled; in the appendix, average pooling is reported to outperform max pooling and FIFO selection. A transformer-based decoder models interactions among anchors and predicts Gaussian attributes:

$$\{\mathcal F_j\}_{j=1}^N = \mathrm{Attn}(\{F_j, A_j\}_{j=1}^N),$$

$$\{\delta \mu_j, \alpha_j, s_j, r_j, sh_j\}_{j=1}^{4N} = \mathrm{MLP}(\{\mathcal F_j\}_{j=1}^N),$$

with Gaussian centers given by

$\mu_j = A_j + \delta \mu_j.$

The reported default is 4 Gaussians per anchor, spherical harmonics degree 0, an 84M-parameter decoder with 16 attention blocks and 640 channels, and 2 single-layer MLP blocks for Gaussian prediction (Zhang et al., 8 Apr 2026).

A distinctive addition is the Gaussian Refiner, a lightweight plug-and-play module trained after freezing the decoder. It renders the current Gaussian scene into the input views, extracts multi-scale features from both rendered and ground-truth images using a pretrained ResNet-18, forms feature-space errors

$e_i = F_i - \hat F_i,$

back-projects these errors to Gaussian locations,

$$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$0

models Gaussian-level error interactions by attention, and predicts Gaussian updates through a Point Transformer-style serial attention block. The refined Gaussians satisfy

$$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$1

The refiner is reported to adjust position, scale, opacity, and color, with 31M parameters, 1 attention block, 4 serialized attention blocks at 512 channels, and 1 single-layer MLP (Zhang et al., 8 Apr 2026).

Training is performed in two stages: 5k steps for the decoder and 5k steps for the refiner, using AdamW, bfloat16, and 64 Ascend 910B3 NPUs. The decoder loss is

$$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$2

with $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$3, $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$4, $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$5, $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$6, $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$7, and $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$8 (Zhang et al., 8 Apr 2026). No per-scene optimization is used at inference.

Empirically, on the ScanNet++ V2 benchmark with 32 source views and 4 novel views, the full model reports PSNR 21.48, SSIM 0.79, LPIPS 0.38, $$\left\{D_i, K_i, P_i \right\}_{i=1}^{V} = \mathrm{MapAnything}(\{I_i\}_{i=1}^V),$$9 0.94, AbsRel 0.066, 247,153 Gaussians, and 5.52 s reconstruction time. In the same setting, AnySplat is reported at 20.20 PSNR, 0.73 SSIM, 0.32 LPIPS, $$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$0 0.71, AbsRel 0.16, 5,550,940 Gaussians, and 6.83 s (Zhang et al., 8 Apr 2026). The paper emphasizes the combination of fixed Gaussian count across changing view counts, substantially fewer primitives, and especially strong depth consistency.

3. AnchorSplat as source-free 3DGS asset refinement

The second AnchorSplat addresses a different problem: given a degraded or low-quality Gaussian asset,

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$1

produce a refined high-quality asset

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$2

Its defining deployment property is that inference is strictly source-free: only the low-quality 3DGS asset is required, and the original multi-view source images are not needed (Zhu et al., 1 Jul 2026).

The method treats a 3DGS asset as an attribute-rich point cloud. For each primitive, all non-positional attributes are concatenated into

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$3

and a Point Transformer v3 encoder produces context-aware features

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$4

These features drive a decoder that generates $$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$5 new primitives per input anchor:

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$6

The output asset is described as being composed of all newly generated primitives (Zhu et al., 1 Jul 2026).

Its central technical device is the Point Anchor Mechanism. The paper argues that unconstrained feature-to-global-primitive generation is ill-posed and leads to gradient confounding, since a local feature could influence arbitrary pixels across arbitrary views. The total loss is written as

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$7

and the unconstrained gradient to feature $$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$8 is

$$\{A_j\}_{j=1}^{N} = \mathrm{ds}\Big(\mathrm{Proj}(\{D_i, K_i, P_i\}_{i=1}^{V})\Big).$$9

To prevent this, every generated primitive is locally attached to its anchor:

$$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$0

Outside the projected local region,

$$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$1

so the gradient becomes localized:

$$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$2

The paper presents this locality constraint as the basis for structural consistency across views (Zhu et al., 1 Jul 2026).

The second key mechanism is the Equivalent Densification Mechanism. Instead of iterative 3DGS cloning, splitting, and pruning, the network performs a one-shot 1-to-$$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$3 expansion. The reported ablation studies $$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$4, and the full model uses $$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$5 (Zhu et al., 1 Jul 2026). Opacity prediction acts as soft pruning by allowing unnecessary descendants to converge toward vanishing opacity. Training is end-to-end through differentiable rendering with

$$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$6

where $$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$7 is VGG-based.

To support evaluation, the paper introduces 3DGS-SR, described as the first large-scale benchmark for this task. It contains approximately 15k single-object assets sourced from Objaverse, with 30 representative objects held out for testing. For each object, 146 views are rendered at both $$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$8 and $$P_w = R_i P_c + T_i = R_i \Big( D_i(u,v) K_i^{-1} \begin{bmatrix} u & v & 1 \end{bmatrix}^\top \Big) + T_i.$$9, standard 3DGS is trained on the low-resolution views for 15,000 iterations to obtain $F_i = E(I_i, D_i, \mathrm{Ray}_i),$0, and assets with PSNR below 34 against their own low-resolution training images are filtered out (Zhu et al., 1 Jul 2026).

On 3DGS-SR at $F_i = E(I_i, D_i, \mathrm{Ray}_i),$1, the method reports 36.57 PSNR, 0.943 SSIM, 0.058 LPIPS, and approximately 0.01 s runtime, compared with 31.03/0.917/0.076 for the raw 3DGS baseline, 34.94/0.924/0.097 for SuperGaussian, and 35.69/0.937/0.074 for Sequence Matters (Zhu et al., 1 Jul 2026). On NeRF-synthetic, it reports 28.97 PSNR, 0.935 SSIM, 0.077 LPIPS, and approximately 0.01 s; the paper stresses that these results are achieved under a stricter source-free constraint than methods that retain access to original images.

4. Anchor mechanisms in the broader 3DGS literature

The two AnchorSplat papers are best understood against a broader anchor-based 3DGS design space. In SOGS, built on Scaffold-GS, an anchor stores an anchor feature vector $F_i = E(I_i, D_i, \mathrm{Ray}_i),$2, a scaling factor $F_i = E(I_i, D_i, \mathrm{Ray}_i),$3, and $F_i = E(I_i, D_i, \mathrm{Ray}_i),$4 offsets $F_i = E(I_i, D_i, \mathrm{Ray}_i),$5; Gaussian attributes are predicted by MLPs as

$F_i = E(I_i, D_i, \mathrm{Ray}_i),$6

with centers

$F_i = E(I_i, D_i, \mathrm{Ray}_i),$7

SOGS then augments compact anchor features with covariance-based second-order statistics and adds a selective gradient loss, explicitly targeting the tradeoff among anchor feature dimensionality, model size, and rendering quality (Zhang et al., 10 Mar 2025).

In dynamic 4D reconstruction, ADC-GS uses anchors as the primary unit of canonical representation, temporal deformation, refinement, and compression. Its canonical organization pairs each anchor with $F_i = E(I_i, D_i, \mathrm{Ray}_i),$8 Gaussian primitives, predicts residual primitive attributes from anchor-conditioned latent codes, and deforms anchors coarsely through time before applying finer appearance refinement. The paper reports 300%–800% rendering speedup over per-Gaussian deformation approaches while maintaining state-of-the-art storage efficiency (Huang et al., 13 May 2025). This makes clear that, in dynamic settings, anchors can function not merely as spatial supports but as motion-sharing and coding units.

In semantic 3DGS, AG$F_i = E(I_i, D_i, \mathrm{Ray}_i),$9aussian uses an anchor-graph structure rather than a flat cloud of free semantic Gaussians. Anchors are obtained from a three-layer multi-resolution voxelization of an SfM sparse point cloud, each anchor stores a center, voxel size, semantic feature, and a small set of child Gaussians, and local graph propagation is used to enforce instance-level semantic coherence (Wang et al., 3 Aug 2025). Here the anchor is a semantic organization primitive as much as a geometric one.

Taken together, these works show that the word "anchor" in 3DGS has become a structural term for localized 3D support and controlled Gaussian generation. The two AnchorSplat papers instantiate that idea in two specific ways: one as a geometry-prior scaffold for feed-forward scene reconstruction, the other as a local refinement scaffold for source-free detail synthesis.

5. Comparison of the two AnchorSplat formulations

The two AnchorSplat methods share a 3D-native bias but diverge in input assumptions, output semantics, and supervision. The feed-forward reconstruction model consumes posed multi-view imagery together with predicted or external geometry priors, constructs anchors by back-projecting depths and downsampling them, and directly predicts a renderable scene representation for novel view synthesis (Zhang et al., 8 Apr 2026). The refinement model begins from an existing 3DGS asset, treats each input primitive as an anchor, and produces a denser output asset by multiplicative local generation, without requiring original source images at inference (Zhu et al., 1 Jul 2026).

Their anchor granularities also differ. In the reconstruction paper, each anchor predicts 4 Gaussians, and the reported ScanNet++ configuration yields 247,153 Gaussians with a fixed count across 32, 48, and 64 source-view settings (Zhang et al., 8 Apr 2026). In the refinement paper, each input primitive generates $3+1+6$0 descendants, with the best reported setting at $3+1+6$1 (Zhu et al., 1 Jul 2026). This suggests two distinct interpretations of anchor locality: one as a compact scene-level scaffold chosen to minimize redundancy, the other as a refinement lattice tied to an existing coarse asset.

The error signals are likewise different. The reconstruction model supplements direct rendering supervision with depth supervision from geometric priors and uses a separate Gaussian Refiner driven by back-projected feature-space residuals between rendered and ground-truth images (Zhang et al., 8 Apr 2026). The source-free refinement model relies on image-level $3+1+6$2, SSIM, and perceptual losses during training, but its principal regularization is architectural rather than loss-based: the Point Anchor Mechanism bounds the spatial support of every generated primitive and thereby localizes gradients (Zhu et al., 1 Jul 2026).

From a systems perspective, the methods address complementary deployment problems. One is intended for fast, feed-forward reconstruction without per-scene optimization. The other is intended for fast, source-free post-processing of already reconstructed or generated Gaussian assets. A plausible implication is that the two uses of the name "AnchorSplat" reflect a broader shift in 3DGS away from unstructured pixel- or primitive-level generation toward controlled local synthesis around explicit 3D support structures.

6. Reported limitations and open directions

The feed-forward reconstruction AnchorSplat explicitly depends on reasonably accurate geometric priors. The paper notes that if priors are incomplete or poor, anchors may miss parts of the scene, constrained local Gaussian growth may fail to cover empty regions, and the fixed Gaussian budget may reduce reconstruction quality in missed areas. It identifies adaptive density control and dynamic Gaussian growth as future directions (Zhang et al., 8 Apr 2026).

The source-free refinement AnchorSplat does not present a dedicated limitations section, but several constraints are stated or implied. Its local-anchor design depends on the coarse input geometry as a scaffold and is therefore best suited to refinement rather than wholesale geometry invention far from the original asset. Training still requires paired high-resolution supervision and camera poses, even though inference is source-free. On cross-dataset evaluation, methods that retain access to original source images can still achieve higher absolute PSNR in some settings, albeit with much greater runtime (Zhu et al., 1 Jul 2026).

These limitations align with recurring constraints in the broader anchor-based literature. SOGS reports slightly increased time complexity from second-order-anchor computation and relies on global cross-anchor feature statistics (Zhang et al., 10 Mar 2025). ADC-GS incurs longer training time than some deformable Gaussian baselines and depends on initialization from sparse point clouds (Huang et al., 13 May 2025). AG$3+1+6$3aussian notes difficulties with glass and metal objects because of feature blending and sensitivity to SAM over-segmentation (Wang et al., 3 Aug 2025). In aggregate, this suggests that anchor-based 3DGS improves structural control, compactness, and locality, but often trades that for dependence on the quality of the underlying geometric or semantic scaffold.

7. Position in the evolution of Gaussian splatting

AnchorSplat occupies an identifiable place in the evolution of 3D Gaussian Splatting from free, per-primitive optimization toward more structured and amortized representations. The feed-forward reconstruction version replaces pixel-aligned generation with anchor-aligned prediction in native 3D space and shows that view-count independence can be achieved by fixing representation size around anchors rather than image grids (Zhang et al., 8 Apr 2026). The source-free refinement version shows that iterative densification can be approximated by a single-pass 1-to-$3+1+6$4 generation rule when anchored to existing Gaussian primitives and trained end-to-end through differentiable rendering (Zhu et al., 1 Jul 2026).

In that sense, "AnchorSplat" does not denote a single canonical method so much as a recurring architectural idea: Gaussian synthesis should be localized around explicit 3D supports. In one formulation, those supports are derived from external or predicted geometry priors; in the other, they are inherited from the low-quality 3DGS asset itself. Both works argue, through different pipelines and benchmarks, that local 3D support structures reduce ambiguity, improve structural consistency, and make Gaussian generation more computationally tractable than unconstrained pixel-aligned prediction or optimization-heavy densification.