Large-Scale High-Quality 3D Gaussian Head Reconstruction from Multi-View Captures

Conference: ECCV 2026
arXiv: 2605.04035
Project: https://apple.github.io/ml-headsup/
Code: None
Area: 3D Vision
Keywords: 3D Gaussian Splatting, Head Reconstruction, Multi-View, UV Parameterization, Feed-Forward Network

TL;DR

HeadsUp proposes a scalable feed-forward method that compresses multi-view images from dynamic camera rigs into compact 2D latent variables via a cross-attention Transformer. These latents are then decoded into UV-parameterized 3D Gaussians anchored to a neutral head template. This decouples the output Gaussian count from the input image resolution and view count, achieving SOTA reconstruction quality on an internal dataset of 10,000+ subjects without requiring test-time optimization.

Background & Motivation

High-fidelity 3D head assets are the cornerstone of photorealistic digital humans, playing a crucial role in close-up rendering scenarios such as telepresence, actor digitization, and content creation. Multi-camera capture systems have become the gold standard for acquiring dense, calibrated head images. However, reliably and efficiently converting these detailed captures into compact 3D reconstructions remains a challenge.

Existing solutions exhibit a fundamental tension between reconstruction fidelity and throughput. On one hand, per-instance optimization methods (e.g., subject-specific fitting based on NeRF or 3DGS) achieve high-quality, view-consistent renderings, but their computational cost makes large-scale deployment impractical. On the other hand, feed-forward reconstruction methods (e.g., Avat3r, pixelSplat, MVSplat) amortize computation over datasets for fast inference, but their computational and VRAM costs typically scale linearly with the number of input views and resolution—hindering full utilization of dense high-resolution capture setups. Additionally, another class of work (e.g., GAGAvatar, ROME, Real3DPortrait) targets drivable avatars, predicting geometry and appearance in a canonical model space. While this supports temporal consistency and control, it often sacrifices the representation capacity required for high-fidelity rendering.

The common limitations of these three lines of work point to a clear demand: can a method fully leverage multi-camera rigs (multi-view, high-resolution, massive identities) while producing compact head assets suitable for photorealistic rendering? Core Idea: Use UV-parameterized 3D Gaussians anchored to a neutral head template as a unified representation to decouple output from input resolution and view count, combined with a cross-attention Transformer to compress multi-view information, along with explicit background modeling and a two-stage training strategy to achieve large-scale, high-fidelity, purely feed-forward head reconstruction.

Method

Overall Architecture

The input to HeadsUp is \(N\) calibrated, time-synchronized multi-view images, and the output is a set of UV-parameterized 3D Gaussians modeling the foreground (head) and background (capture environment) separately. The overall pipeline consists of four stages: image patching and feature extraction, multi-view encoding, Gaussian UV decoding, and differentiable rendering with end-to-end supervision.

Input images are first patched (\(7 \times 7\) patches) and concatenated with Plücker ray embeddings to explicitly encode camera geometry. Two parallel convolutional encoders decouple each view into foreground features and background features. Foreground features are fed into a cross-attention Transformer, mapping a set of learnable 2D query tokens into a compact 2D latent variable \(Z\) (\(64 \times 64\), 512 dimensions), which aggregates information from an arbitrary number of input views using cross-attention. Background features are compressed into a compact background latent \(z_{\text{bg}}\) via a shallow convolutional network and global average pooling. The two latent variables are fed into independent Gaussian UV decoders to generate Gaussian attribute UV maps anchored to template meshes (a neutral head template for the foreground, and a spherical template for the background). Finally, the 3DGS differentiable renderer is used to render from arbitrary novel views, and losses are computed against ground-truth images.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["N Calibrated Multi-View Images"] --> B["Patching + Plücker Embedding<br/>Two-way Convolutional Encoder"]
    B --> C["Foreground Features"]
    B --> D["Background Features"]
    C --> E["Cross-Attention Transformer<br/>→ Foreground Latent Z"]
    D --> F["Shallow CNN + Global Pooling<br/>→ Background Latent z_bg"]
    E --> G["3D Gaussian UV Decoder (Foreground)<br/>→ UV-Parameterized 3D Gaussians"]
    F --> H["3D Gaussian UV Decoder (Background)<br/>→ Spherical-Anchored Background Gaussians"]
    G --> I["Joint Differentiable Rendering"]
    H --> I
    I --> J["L1 + Multi-scale LPIPS + Adversarial + Regularization"]

Key Designs

1. UV-Parameterized 3D Gaussian Representation: Decoupling Output Gaussian Count from Input Resolution/View Count

Traditional pixel-aligned methods (e.g., Avat3r, FastGHA) predict one Gaussian per input pixel, resulting in a Gaussian count that scales linearly with input image resolution and view count, which leads to VRAM explosion under dense multi-view, high-resolution settings. The core innovation of HeadsUp is anchoring 3D Gaussians to a neutral head template shared across all identities, predicting Gaussian attributes in a UV space (\(256 \times 256\) resolution)—where each UV coordinate corresponds to one Gaussian, totaling approximately 65K foreground Gaussians. The neutral template is defined in a canonical coordinate system (origin at the midpoint of pupils, orientation aligned with the Frankfurt plane), and the 3D position of each Gaussian is obtained by adding a bounded offset (scaled to 200mm using tanh) to the template vertex position:

\[\boldsymbol{\mu}_{u,v} = \mathbf{V}(u,v) + \mathbf{U}^{(\mu)}(u,v), \quad \|\mathbf{U}^{(\mu)}(u,v)\| \leq \delta_{\max}\]

Other attributes are decoded from the UV feature map via respective activation functions: scales use exponential activation \(\mathbf{s}_{u,v} = \exp(\mathbf{U}^{(s)}(u,v))\), rotations use L2 normalization \(\mathbf{q}_{u,v} = \text{normalize}(\mathbf{U}^{(q)}(u,v))\), opacity uses sigmoid \(\alpha_{u,v} = \sigma(\mathbf{U}^{(\alpha)}(u,v))\), and spherical harmonic color coefficients (L=1) are directly outputted. This UV representation has three major advantages: (1) Shared geometric prior—the canonical mesh topology provides a consistent spatial structure across all subjects and expressions, allowing the network to focus on appearance and local variations; (2) Efficient multi-view aggregation—the number of output Gaussians is fixed and independent of the input, enabling the processing of an arbitrary number of high-resolution views; (3) Robustness to tracking errors—it only requires rigid head pose tracking and does not rely on fragile and error-prone expression tracking.

2. Cross-Attention Transformer Multi-view Encoder: Compressing Arbitrary View Counts into a Compact 2D Latent

Multi-view information aggregation is a core challenge in feed-forward reconstruction. HeadsUp uses an 8-layer, 8-head cross-attention Transformer with a hidden dimension of 512 to aggregate foreground features from \(N\) views (flattened into key-value tokens) onto a set of learnable 2D query tokens (\(64 \times 64\) grid, 512 dimensions), outputting a 2D latent \(Z\) of the same resolution. The key design is that the number and resolution of query tokens are fixed (4096), independent of the number of input views. Adding a view only increases key-value tokens; since the computational complexity of cross-attention is quadratic with the number of queries rather than keys and values, the computational overhead of scaling views remains highly manageable.

Patch embeddings of the input images are first concatenated channel-wise with 6D Plücker ray embeddings, explicitly injecting per-pixel camera ray geometry. These concatenated features are processed by a convolutional network (1 downsampling + 4 bottleneck residual blocks, outputting 512 channels) to extract foreground feature maps. The query grid of the Transformer provides a fixed spatial structure, which subsequent decoders can directly reshape into UV maps, while the cross-attention mechanism aggregates information from arbitrary viewpoints. Ablation experiments show that PSNR consistently improves as the Transformer increases from 2 to 8 layers (\(28.24 \rightarrow 28.89\) dB), saturating beyond 8 layers. When the latent resolution increases from \(16 \times 16\) to \(128 \times 128\), the PSNR rises from \(27.59\) to \(29.66\) dB, indicating it is the most critical factor for model capacity.

3. Explicit Background Modeling: Eliminating Matting Dependency and Recovering High-Frequency Boundary Details

In multi-view head reconstruction, foreground matting is a common pre-processing step—segmenting the foreground first and reconstructing only the foreground region. However, matting inevitably introduces errors when handling semi-transparent or fine boundary structures like hair strands and earrings, which propagate to the reconstruction model, causing boundary blurring or artifacts. HeadsUp introduces a lightweight, dedicated background model to avoid this issue: in the two-way encoder, the background branch uses a shallower convolutional network (two downsamplings, channels \(128 \rightarrow 64\)) to extract per-view background features. These are compressed via multi-view global average pooling and a two-layer MLP into a compact 1D latent \(z_{\text{bg}}\) (32-channel bottleneck), which is then decoded by a 7-stage progressively upsampled residual network into approximately 262K background Gaussians anchored to the cylindrical/spherical template of the capture rig (with position offset bounded at 10mm, much tighter than the 200mm for foreground, since the background is static).

During training, foreground and background Gaussians are jointly rendered in the canonical coordinate system and optimized against the raw, un-matted ground-truth images. The background model automatically learns to model the capture environment (e.g., lights, rigs) without any ground-truth background supervision. During inference, the background branch is discarded, and only foreground Gaussians are utilized. Ablation studies confirm that removing the background model leads to significant degradation in semi-transparent regions and fine foreground elements (such as hair color shifting). The elegance of this design lies in bypassing the pixel-level matting pre-processing bottleneck—a long-standing issue in multi-view reconstruction—at an extremely low cost (the background encoder is much smaller than the foreground).

4. Two-Stage Training and Region-Aware Loss: Low-Resolution Pre-training + High-Resolution Fine-Tuning + Dedicated Supervision for Eye and Mouth Regions

Directly training the Transformer end-to-end on the native resolution (\(1000 \times 750\)) is highly computationally expensive (attention scale is quadratic with token count). HeadsUp adopts a two-stage strategy: the first stage trains for 900K steps (batch size 64) on 2x downsampled images (\(500 \times 375\)) to let the model learn coarse geometry and appearance; the second stage fine-tunes for 200K steps (batch size 32) on the native resolution (\(1000 \times 750\)) to unlock high-frequency detail modeling.

The second stage introduces two key modifications. Region-specific loss: Utilizes the canonical coordinate system to crop regions around the eyes and mouth, applying additional multi-scale LPIPS perceptual loss on these regions—since human perception is highly sensitive to these facial focal points. Ablations show that removing the eye loss drops eye-crop PSNR by 1.56 dB, and removing the mouth loss drops mouth-crop PSNR by 1.97 dB. Multi-resolution loss strategy: The authors observed that applying global perceptual (LPIPS) and discriminator losses directly at native resolution leads to training instability (likely due to noisy high-frequency gradients). Thus, they compute the global LPIPS and adversarial losses on the 2x downsampled output instead, using native resolution only for cropped regions. Removing this half-resolution loss causes the overall PSNR to crash by 3.55 dB, verifying its critical role as a coarse-to-fine gradient stabilizer.

An Complete Example: From 10 Multi-view Images to Renderable 3D Head

Taking a typical inference scenario from the Internal10K dataset as an example. The input consists of 10 calibrated multi-view images (\(1000 \times 750\)), covering the front, side, and oblique views of the subject's face. Each image is first split into \(7 \times 7\) patches (with images scaled to fit the patch size), generating 256-dimensional patch embeddings. These are concatenated with 6D Plücker embeddings to produce 262-dimensional per-patch features. The foreground convolutional encoder processes these features into a 512-channel feature map (spatial resolution of approx. \(143 \times 107 \rightarrow\) approx. \(72 \times 54\) after downsampling). Flattening the features across 10 views yields around 38,880 key-value tokens, which are fed into an 8-layer cross-attention Transformer. Through cross-attention with 4096 (\(64 \times 64\)) learnable query tokens, it outputs a \(64 \times 64 \times 512\) latent variable \(Z\). Meanwhile, the background encoder compresses the 10-view background features (256 channels) via global average pooling into \(z_{\text{bg}}\) (32 dimensions).

The latent variable \(Z\) is upsampled by the foreground decoder (two 2x nearest-neighbor upsamplings, channels \(512 \rightarrow 256\)) to a resolution of \(256 \times 256\), and a final \(3 \times 3\) convolution projects it into a 23-channel UV feature map (position offset 3 + scale 3 + rotation 4 + opacity 1 + SH coefficients 12)—totaling 65,536 foreground Gaussians. The background latent is decoded via a 7-stage upsampling into a \(512 \times 512\) UV map, yielding approx. 262K background Gaussians. Both sets of Gaussians are merged in the canonical coordinate system, differentiably rasterized and rendered for any specified camera pose to output synthetic images. The entire process takes only 0.33 seconds on a single A100 (for 16 views), which is over 30x faster than Avat3r's 10.8 seconds (for 6 views).

Loss & Training

The total loss consists of reconstruction and regularization terms:

\[\mathcal{L}_{\mathrm{total}} = \lambda_{\mathrm{L1}}\mathcal{L}_{\mathrm{L1}} + \lambda_{\mathrm{LPIPS}}\mathcal{L}_{\mathrm{LPIPS}} + \lambda_{\mathrm{adv}}\mathcal{L}_{\mathrm{adv}} + \lambda_{\mathrm{pos}}\mathcal{L}_{\mathrm{pos}} + \lambda_{\mathrm{mask}}\mathcal{L}_{\mathrm{mask}} + \lambda_{\mathrm{TV}}\mathcal{L}_{\mathrm{TV}}\]

where \(\lambda_{\mathrm{L1}}=1.0\), \(\lambda_{\mathrm{LPIPS}}=0.1\), \(\lambda_{\mathrm{adv}}=0.25\), and \(\lambda_{\mathrm{TV}}=10.0\). \(\mathcal{L}_{\mathrm{L1}}\) is the pixel-wise L1 photometric loss. \(\mathcal{L}_{\mathrm{LPIPS}}\) is the sum of AlexNet-LPIPS perceptual losses across three scales (original resolution, 2x downsampled, 4x downsampled). \(\mathcal{L}_{\mathrm{adv}}\) is the adversarial loss based on a perceptual discriminator (operating on random \(256 \times 256\) crops), activated only after 240K steps of training to ensure stability.

For regularization terms: \(\mathcal{L}_{\mathrm{pos}}\) constrains the Gaussian positions during a warm-up phase to be close to the corresponding 3D points on the expression tracking mesh (via barycentric interpolation of UV coordinates), with its weight linearly decaying from 1.0 to 0.01 (first 100K steps). \(\mathcal{L}_{\mathrm{mask}}\) minimizes the difference between the rendered foreground alpha map and the ground-truth segmentation mask, with its weight decaying from 2.0 to 0.1 (first 100K steps). \(\mathcal{L}_{\mathrm{TV}}\) is applied to the rendered colors in the UV space to encourage spatial smoothness and prevent rendering holes.

Optimization uses Adam (lr=2e-4, mixed precision with bfloat16). Opacity and scale are detached from the gradient map in the first 1000 steps for warm-up. Stage 1 is trained on 16 H100 GPUs for about 10 days, and Stage 2 takes about 2 days. Fine-tuning on Ava-256 takes less than 1 day.

Key Experimental Results

Main Results

Dataset	Method	#Views	#Gaussians	PSNR↑	SSIM↑	LPIPS↓	AKD↓	CSIM↑
Internal10K	Avat3r	4	0.8M	24.10	0.830	0.371	12.78	0.738
Internal10K	Avat3r	6	1.1M	24.37	0.831	0.362	12.99	0.787
Internal10K	HeadsUp	10	65K	29.25	0.821	0.117	10.39	0.922
Ava-256	Avat3r	4	0.8M	21.54	0.788	0.370	6.39	0.698
Ava-256	Avat3r	6	1.1M	22.31	0.795	0.359	6.10	0.775
Ava-256	HeadsUp	4	65K	23.64	0.805	0.178	5.09	0.833
Ava-256	HeadsUp	6	65K	24.62	0.815	0.161	4.70	0.873
Ava-256	HeadsUp	16	65K	26.13	0.831	0.110	4.27	0.914

HeadsUp significantly outperforms Avat3r across all metrics, with the most notable gaps in LPIPS (perceptual similarity) and CSIM (identity preservation), while using only 1/12 to 1/17 of the Gaussian count of Avat3r. Notably, Avat3r is bottlenecked by VRAM and suffers OOM at 6 views, whereas HeadsUp scales effortlessly beyond 16 views.

Inference speed comparison (single A100):

Method	4-View Time (s)	6-View Time (s)	16-View Time (s)	4-View FPS	6-View FPS	16-View FPS
Avat3r	5.6	10.8	OOM	0.18	0.09	OOM
HeadsUp	0.14	0.20	0.33	7.14	4.94	2.93

Ablation Study

Ablation Dimension	Configuration	PSNR↑	LPIPS↓	AKD↓
Training Identities	250 subjects	22.19	0.267	6.27
	1K subjects	25.92	0.164	3.97
	4K subjects	28.46	0.103	3.23
	10K subjects	28.89	0.096	3.20
Number of Input Views	1 view	22.98	0.208	5.08
	4 views	26.51	0.135	3.91
	8 views	28.26	0.105	3.35
	16 views	29.03	0.096	3.36
Template Type	Expression tracking mesh	26.77	0.184	4.01
	Fixed neutral mesh	28.89	0.096	3.20
Latent / Gaussian UV Resolution	16/256	27.59	0.121	3.59
	32/256	28.89	0.096	3.20
	64/256	29.21	0.089	3.00
	128/512	29.66	0.083	3.04
Number of Supervision Views	1 target view	28.89	0.096	3.20
	8 target views	29.54	0.093	2.97
Number of Transformer Blocks	2 blocks	28.24	0.102	3.40
	8 blocks	28.89	0.096	3.20
	12 blocks	28.89	0.096	3.36

High-resolution fine-tuning ablation	Full Image PSNR↑	Eye Crop PSNR↑	Mouth Crop PSNR↑
Full Model	28.35	31.94	32.14
w/o Eye Loss	28.33	30.38	32.27
w/o Mouth Loss	28.20	31.78	30.17
w/o HalfRes Loss	24.80	28.26	30.54

Key Findings

• Training identities are a decisive factor: Scaling from 250 to 2K subjects yields a stable 1.7-1.8 dB PSNR gain per doubling, exhibiting a log-linear scaling behavior. With fewer than 1K subjects, the model fails catastrophically on out-of-distribution faces. Diminishing returns occur beyond 4K subjects.
• Model capacity is more important than Gaussian count: Doubling the latent resolution from \(16 \times 16\) to \(128 \times 128\) increases PSNR by 2.07 dB. In contrast, doubling the Gaussian UV resolution from 256 to 512 (which quadruples the Gaussians) brings negligible gains under the same latent resolution. This demonstrates that encoder capacity, rather than Gaussian count, is the bottleneck for reconstruction quality.
• Fixed neutral template outperforms expression-tracked template (+2.12 dB PSNR): Expression-tracked meshes introduce frame-by-frame vertex displacement noise, whereas the neutral template provides a stable canonical surface, allowing the Gaussian decoder to focus on appearance variation.
• More supervision views are better: Increasing from 1 target view to 8 target views improves PSNR by 0.65 dB and decreases AKD by 0.23—multi-view supervision enforces the generation of view-consistent geometry.
• Background modeling is crucial for boundary details like hair: Without the background model, the model hallucinates background artifacts in the hair region.
• Monocular model can already reconstruct convincingly: Using only 1 frontal view, the PSNR still reaches 22.98 dB, showcasing the robustness and generalization capability of the method.

Highlights & Insights

• UV decoupling is the most central architectural insight: Shifting the output space from "pixel-aligned" to "template UV space", and using a fixed 65K Gaussians to represent inputs of arbitrary resolution and view counts. This design choice simultaneously addresses the VRAM bottleneck, multi-view aggregation efficiency, and tracking error robustness, achieving a leverage effect where one architectural framework benefits multiple dimensions.
• Background as an auxiliary task rather than preprocessing: Traditional pipelines treat foreground segmentation as an independent preprocessing step. HeadsUp turns background modeling into an auxiliary decoding branch, jointly optimized during training and discarded during inference. This "use-and-discard" design avoids the propagation of matting errors without adding any inference load, which could be transferred to other vision tasks requiring foreground/background separation (such as object or scene reconstruction).
• The multi-resolution loss strategy in two-stage training is a practical trick to stabilize training: Downsampling the global loss in the high-resolution stage and using the native resolution only for crucial regions (eyes, mouth) essentially controls the frequency components of the gradient signal, preventing high-frequency noise from destabilizing the discriminator training. This trick is highly transferable to any generative/reconstruction tasks that require adversarial training at very high resolutions.
• Log-linear identity data scaling law: PSNR increases by a stable 1.7-1.8 dB for every doubling of the training identity count (up to 2K subjects). This is formally similar to the scaling laws of LLMs, suggesting that representation learning in 3D head reconstruction also follows a power law, providing a practical reference for estimating future data demands.

Limitations & Future Work

• Reliance on calibrated multi-camera capture rigs: The method is designed specifically for studio environments, and its generalization to in-the-wild scenarios (such as single mobile phone photos or outdoor selfies) has not been systematically validated. The paper only demonstrates a preliminary single-view reconstruction of AI-generated images as a proof of concept, acknowledging that the model is not yet robust to unconstrained data.
• Background model assumes a static setup: The background branch assumes that the capture rig background remains static and is not applicable to dynamic background environments. Discarding the background model during inference implies that actual deployment still requires other means to handle the background.
• Limited expression control: Although blendshape-driven animation can be completed in the latent space without per-identity fine-tuning, the paper does not systematically evaluate its quality under extreme expressions and large head rotations compared to dedicated animation methods (like GaussianAvatars or GAF).
• 10,000-subject dataset is proprietary: Model training relies on Apple's internal dataset, making it impossible for external researchers to reproduce the full training pipeline. Although fine-tuning results on Ava-256 are reproducible, the pre-training on Internal10K is the core basis of the performance.
• High computational resource barrier: Full training requires 16 H100 GPUs for about 12 days, which is impractical for most academic labs. However, inference is extremely lightweight (0.33 seconds on a single A100, and 65 FPS for blendshape animation on a MacBook), lowering the bar for actual deployment.

Related Work & Insights

• vs Avat3r (ECCV 2024): Current SOTA in feed-forward head reconstruction. Avat3r uses DUSt3R position maps and Sapiens features for pixel-aligned Gaussian prediction, which is a "template-free" approach. The core difference of HeadsUp lies in the use of UV parameterization to decouple output and input, and cross-attention instead of pixel alignment, thus breaking free from the view count-VRAM linear binding bottleneck. Avat3r suffers OOM at 6 views, while HeadsUp easily scales to 16+ views and is faster. However, Avat3r does not require a template mesh, making it more flexible for non-human head applications.
• vs FastGHA (CVPR 2026): Also performs pixel-aligned Gaussian prediction, relying on DINOv3 and SD-VAE features. HeadsUp comprehensively outperforms it on the Internal10K half-resolution (PSNR 26.51 vs 22.76, LPIPS 0.135 vs 0.222). The pixel-aligned nature of FastGHA similarly limits its view-count scalability.
• vs GaussianAvatars (CVPR 2024): Binds 3D Gaussians to the FLAME parametric model to achieve fully controllable heads but requires per-subject optimization (on the scale of minutes). HeadsUp also anchors Gaussians to a template but uses a fixed neutral template (without depending on speech/expression parameters) and is purely feed-forward. The distinction between these two suggests that "fixed template + feed-forward" might be more suitable for large-scale, high-quality reconstruction than "parametric model + optimization."
• vs Pippo (CVPR 2025): Uses DiT for single-image head generation, offering high quality but requiring minutes for multi-view inference and failing to guarantee strict 3D consistency. HeadsUp has a natural advantage in speed (0.33 seconds vs minutes) and 3D consistency, though Pippo shows stronger single-image generalization.

Rating

• Novelty: ⭐⭐⭐⭐☆ UV parameterization for 3DGS heads is not a completely new concept (LAM, PanoLAM, etc., also operate in UV space), but the combined scheme of "UV-decoupled input/output + cross-attention latent + explicit background" is pioneering in head reconstruction and addresses a clear practical pain point (multi-view scaling bottleneck).
• Experimental Thoroughness: ⭐⭐⭐⭐⭐ 10,000-subject scale training, systematic scaling law analysis (ablation across 7 dimensions: identity count, view count, capacity, supervision density, and Transformer layers), two datasets, inference speed comparison, and downstream application demonstrations (text-to-identity generation + blendshape animation). The experiments are highly comprehensive and the conclusions are clear.
• Writing Quality: ⭐⭐⭐⭐⭐ Well-structured with a complete motivational thread (deriving requirements from the limitations of three separate paths). The method is detailed, and the ablation experiments are organized by dimensions with independent summaries. The supplementary material is thorough (complete hyperparameter tables, architectural details, baseline reproduction details).
• Value: ⭐⭐⭐⭐☆ Highly practical for industrial scenarios requiring large-scale studio head reconstruction (movies, games, telepresence); the scaling law analysis provides valuable insights for future work. However, the reliance on studio rigs and proprietary data limits direct follow-ups by the academic community.

Related Papers

• [CVPR 2025] HRAvatar: High-Quality and Relightable Gaussian Head Avatar
• [ECCV 2026] AnyMatch: Supercharging Universal Multi-Modal Image Matching with Large-Scale Single-View Images
• [ECCV 2026] Capacity-Controlled Multi-View Stylization of 3D Gaussian Splatting
• [CVPR 2026] Confidence-Guided Multi-Scale Aggregation for Sparse-View High-Resolution 3D Gaussian Splatting
• [CVPR 2026] Skullptor: High Fidelity 3D Head Reconstruction in Seconds with Multi-View Normal Prediction