Long-LRM: Long-sequence Large Reconstruction Model for Wide-coverage Gaussian Splats

## Abstract

Abstract We propose Long-LRM, a generalizable 3D Gaussian reconstruction model that is capable of reconstructing a large scene from
a long sequence of input images. Specifically, our model can process 32 source images at 960 × \times 540 resolution within only 1.3 seconds on a single A100 80G GPU. Our architecture features a mixture of the recent Mamba2 blocks and the classical transformer blocks which allowed many more tokens to be processed than prior work, enhanced by efficient token merging and Gaussian pruning steps that balance between quality and efficiency.
Unlike previous generalizable 3D GS models that are limited to taking 1 ∼ similar-to \sim 4 input images and can only reconstruct a small portion of a large scene, Long-LRM reconstructs the entire scene in a single feed-forward step.
On large-scale scene datasets such as DL3DV-140 and Tanks and Temples, our method achieves performance comparable to optimization-based approaches while being two orders of magnitude more efficient. Project page: https://arthurhero.github.io/projects/llrm/

## 1 Introduction

3D reconstruction from multi-view images is a fundamental problem in computer vision, with applications ranging from 3D content creation, VR/AR, to autonomous driving and robotics.
Recently, NeRF (Mildenhall et al., ) and various radiance field-based methods (Müller et al., ; Xu et al., ; Chen et al., ; Barron et al., ) have shown great potential in reconstructing high-quality 3D scenes from a set of posed images via differentiable rendering. However, these models are slow to reconstruct and not generalizable to unseen scenes, as they require optimization for each scene independently.
While 3D Gaussian splatting (GS) (Kerbl et al., ) has significantly advanced the reconstruction and rendering efficiency, it still typically requires at least 10 minutes to optimize for each scene and can not achieve an instant reconstruction.

Recently, generalizable 3D GS models (Szymanowicz et al., ; Tang et al., ) have been proposed to enable fast feed-forward GS reconstruction, avoiding per-scene optimization. Several methods (Charatan et al., ; Zhang et al., ; Liu et al., ; Chen et al., ) have shown promising scene-level reconstruction results on real 3D captures by regressing per-pixel Gaussian primitives.
In particular, GS-LRM (Zhang et al., ), following the principles of 3D large reconstruction models (LRMs) (Hong et al., ; Li et al., ; Wang et al., ) and leveraging a densely self-attention-based transformer (Vaswani, )
without using 3D inductive biases such as epipolar attention or sweeping volumes,
has achieved state-of-the-art novel-view rendering quality on multiple challenging datasets.
However,
the previous generalizable GS models are designed to handle a small number of input images (typically 1$\sim$4) with limited viewing coverage,
thus are incapable of reconstructing large real-world scenes, which require a wide view span and at least dozens of images. In such cases, per-scene optimization-based methods were still the only viable option.

Our goal is to enable fast and accurate GS reconstruction of large scenes with wide viewing coverage through direct feed-forward network prediction.
To this end, we propose Long-LRM, a novel GS-based LRM that is able to *handle long-sequence input and achieve high-quality 3D GS reconstruction of large scenes from as many as 32 widely-displaced multi-view images at 960$\times$540 resolution within only 1.3 seconds* on a single A100 80G GPU. As shown in Fig. [1](#S0.F1), the photorealistic novel-view renderings produced by our approach has a quality comparable to or even better than 3D GS (Kerbl et al., ) that takes over 10 minutes for per-scene optimization.

Specifically, as inspired by GS-LRM, we patchify the multi-view input images into a sequence of patch tokens and consider the task of GS reconstruction as a sequence-to-sequence translation to regress pixel-aligned Gaussian primitives. However, unlike GS-LRM that focuses on 2-4 input images, our input setting with 32 960$\times$540 images corresponds to an extremely long token sequence – about 250K context length (considering a patch size of $8\!\times\!8$) – which is highly challenging for dense transformers (as used by GS-LRM) due to their quadratic time complexity.
Note that this length is even larger than many modern large language models (LLM), such as LLama3 (Dubey et al., ) with a context length of 128K.

To address this challenge, we leverage the recent advancements of state space models (SSMs) (Gu & Dao, ), designed to handle long-context reasoning efficiently with linear complexity.
In particular, we propose a novel LRM architecture that combines Mamba2 (Dao & Gu, ) blocks with transformer blocks, enabling efficient sequential long-context reasoning while preserving critical global context.
Additionally, we introduce a token merging module to further reduce the number of tokens in the middle of the network processing, along with a Gaussian pruning step to encourage efficient use of the dense per-pixel Gaussians.
These combined designs allow us to train our Long-LRM using similar computational resources to GS-LRM, while successfully scaling up the input sequence length and achieving over $10\times$ faster training on long-sequence inputs, enabling fast, high-quality, wide-coverage reconstruction of large real scenes (see Tab. [2](#S5.T2)).

We train our Long-LRM on the recent DL3DV dataset (Ling et al., ), which comprises approximately 10K diverse indoor and outdoor scenes. We evaluate our model on both the DL3DV test set and the Tanks and Temples dataset (Knapitsch et al., ), using 32 input images for each scene. The results show that our direct feed-forward reconstruction achieves comparable novel view synthesis quality to the per-scene optimization results of 3D GS, while substantially reducing the reconstruction time – by two orders of magnitude (1.3 seconds vs. 13 minutes). Our approach is the first feed-forward GS solution for wide-coverage scene-level reconstruction and the first to enable large-scale GS scene reconstruction in seconds.

## 2 Related Work

3D Reconstruction. Many traditional and learning-based 3D reconstruction methods have been focusing on pure geometry reconstruction, where surface meshes (Murez et al., ; Sun et al., ; Bozic et al., ; Stier et al., ) or depth maps (Zbontar & LeCun, ; Schönberger et al., ; Yao et al., ; Cheng et al., ; Kar et al., ; Duzceker et al., ; Sayed et al., ) are the target output. These methods usually involve explicit feature matching along the epipolar lines, followed by the prediction of TSDF or depth values performed by the neural networks. In contrast, we adopt the recent 3D GS representation for joint geometry and appearance reconstruction, allowing for photo-realistic novel view synthesis.

Neural reconstruction and rendering.
Instead of directly predicting the surface geometry, NeRF (Mildenhall et al., ) proposes to leverage differentiable volume rendering to regress novel-view images, supervised with a rendering loss.
This implicit way of reconstruction eliminates the need for hard-to-obtain ground-truth 3D supervision while producing visually pleasing reconstruction results.
However, NeRF reconstruction requires optimizing its network for each scene independently, taking hours or even days for reconstruction.
Follow-up works have introduced advanced neural scene representations (Barron et al., ; Müller et al., ; Chen et al., ; Xu et al., ; Tancik et al., ; Barron et al., ) and largely improved the time and memory efficiency – with 3D Gaussian splatting (Kerbl et al., ) notably reducing the reconstruction time to dozens of minutes while keeping high reconstruction quality and enabling real-time rendering, but these methods are still unable to achieve instant prediction.
We aim to build a scalable feed-forward reconstruction model, capable of achieving instant 3D GS reconstruction in seconds.

Generalizable NeRF and 3D GS.
Previous attempts to develop generalizable NeRF models have primarily relied on classical projective geometric structures, such as epipolar lines (Yu et al., ; Wang et al., ; Liu et al., ; Suhail et al., ) or plane-sweep cost volumes (Chen et al., ; Johari et al., ; Lin et al., ; Zhang et al., ), to aggregate multi-view features from nearby views for local NeRF estimation.
Recently, similar designs have been adapted to enable feed-forward scene-level 3D GS reconstruction with generalizable models (Charatan et al., ; Chen et al., ; Liu et al., ).
However, since both epipolar geometry and plane-sweep volumes depend on significant overlap between input views, these GS-based methods (as well as most prior NeRF-based methods) are limited to local reconstructions from a small number (1$\sim$4) of narrow-baseline inputs.
On the other hand, GS-LRM (Zhang et al., ) avoids these 3D-specific structural designs and adopts an attention-based transformer, achieving state-of-the-art performance in this domain.
However, GS-LRM still focuses on solving the problem of local reconstruction from just 2$\sim$4 views.
In contrast, our model supports feed-forward 3D GS reconstruction from 32 input images, enabling complete reconstruction of large scenes.

Efficient models for long sequences.
Transformer-based 3D large reconstruction models (LRMs) have emerged (Hong et al., ; Li et al., ; Xu et al., ; Wang et al., ; Wei et al., ; Xie et al., ; Zhang et al., ), enabling high-quality 3D reconstruction and rendering from sparse-view inputs.
While transformers dominate various AI fields due to their flexibility with input modalities and scalability in model sizes, their quadratic time complexity makes them extremely slow when handling long sequences, often requiring thousands of GPUs for parallel computing (Dubey et al., ).
Efficient architectures such as linear attention (Katharopoulos et al., ) and structured state space model (SSM) (Gu et al., ) have been proposed in NLP to deal with large corpus of text.
Mamba (Gu & Dao, ), a variant of SSM, offers significant improvements by computing state parameters from each input in the sequence and has been successfully extended to tackle vision tasks (Zhu et al., ; Liu et al., ; Lieber et al., ; Huang et al., ).
Mamba2 (Dao & Gu, ) further restricts the state matrix $A$ and expands state dimensions, showing performance comparable to transformers on multiple language tasks.
However, empirical studies (Waleffe et al., ) indicate that transformers still outperform Mamba2 in in-context learning and long-context reasoning—both critical for 3D reconstruction.
Inspired by the findings and hybrid models from Waleffe et al. () and Jamba (Lieber et al., ), we propose to apply a hybrid architecture combining transformer and Mamba2 blocks for long-sequence 3D GS reconstruction, achieving a balance between training efficiency and reconstruction quality (see Tab. [2](#S5.T2)).

## 3 Method

Figure: Figure 2: Long-LRM takes up to 32 input images along with their Plücker ray embeddings as model input, which are then patchified, linearly transformed, and concatenated into token sequences. These tokens are processed through an optional token merging module, followed by a sequence comprising Mamba2 blocks (×7) and a Transformer block (×1). This entire processing structure is repeated three times (×3) to ensure effective handling of the long-sequence inputs and comprehensive feature extraction. Fully processed, the tokens are unpatchified and decoded into Gaussian parameters, followed by Gaussian pruning to generate the final 3D GS representation. The bottom section of the figure illustrates the resulting novel view synthesis and wide-coverage Gaussian reconstruction, demonstrating Long-LRM’s capability to handle extensive view coverage and produce high-quality, photorealistic reconstructions.
Refer to caption: /html/2410.12781/assets/x2.png

We present our Long-LRM method in this section.
We give an overview in Sec. [3.1](#S3.SS1), the implementation details of the Mamba2 blocks in Sec. [3.2](#S3.SS2) and additional designs for memory reduction (e.g., token merging) in Sec. [3.3](#S3.SS3).
We end with a discussion of the training objectives in Sec. [3.4](#S3.SS4) that help the model to effectively converge.

### 3.1 Overall Architecture

As shown in Fig. [2](#S3.F2), we follow prior work (Xu et al., ; Wei et al., ; Zhang et al., ) to tokenize the channel-wise concatenated RGB images and Plücker rays. Similar to GS-LRM (Zhang et al., ), we view the per-pixel GS prediction as a sequence-to-sequence mapping.
But crucially, we use a hybrid of Mamba2 blocks and transformer blocks, following the studies in Waleffe et al. () and Lieber et al. (), for better scalability to higher resolution and denser views, while GS-LRM solely builds upon transformer blocks.

In our implementation, each hybrid block consists of 7 Mamba blocks and one transformer block, which we empirically observe to be a balanced configuration.
For the transformer blocks, we use global self-attention, as done in recent LRMs (Wei et al., ; Zhang et al., ).
We detail our implementation of Mamba2 blocks in Sec. [3.2](#S3.SS2).
A token merging stage is optionally injected before the hybrid block to further speed up the processing, which is detailed later in Sec. [3.3](#S3.SS3).

We decode per-pixel Gaussian parameters from the output tokens in the same way as GS-LRM. But we apply additional training-time and test-time pruning of the extremely dense Gaussians to improve efficiency at high resolution and increased views.

### 3.2 Mamba2 Block

A Mamba block (Gu & Dao, ), similar to a transformer block, processes a token sequence of shape $L\!\times\!D$ by mixing the token information, and outputs a token sequence of the same shape.
For a sequence of length $L$, transformer block has a computational complexity of $O(L^{2})$ while Mamba effectively reduces it to $O(L)$.
Thus, it is suitable for the dense reconstruction task in our Long-LRM.

Being a variant of SSM, Mamba at its core processes each input token $x$ by formula

$$ $\displaystyle h_{t}$ $\displaystyle=\textbf{A}h_{t-1}+\textbf{B}x_{t}$ (1) $\displaystyle y_{t}$ $\displaystyle=\textbf{C}h_{t}$ (2) $$

where $h$ is the hidden state, $y$ is the output token, $t$ is the sequence index, and $\textbf{A},\textbf{B},\textbf{C}$ are parameters. Different from previous work (Gu et al., ), Mamba computes $\textbf{A},\textbf{B},\textbf{C}$ from the input with a linear layer instead of storing them as model parameters. It’s worth noting that similar to transformer block, Mamba block can be highly parallelized in terms of computation for leveraging the massive GPU compute power, which is one core factor driving its increasing popularity.

The novel Mamba2 (Dao & Gu, ) block improves over Mamba by further restricting the state matrix $\mathbf{A}$ to be a scalar times identity structure, allowing the usage of efficient block multiplication and expansion to larger state dimensions, showing performance comparable to transformers on multiple language tasks.
However, since the Mamba2 block is designed for language tasks, it only scans through the tokens in one direction, which is suboptimal for images. Following Vision Mamba (Zhu et al., ), we take bi-directional scans over the concatenated token sequence. Specifically, we first compute the state parameters from the input using one linear layer; then we run the SSM block in both forward and backward directions on the token sequence. Finally, we sum up the output tokens from the two scans before going through another linear layer.
We also did some preliminary exploration of more complex scan patterns as in VMamba (Liu et al., ) and LocalMamba (Huang et al., ), but we observed a substantial decrease in speed, and hence we decided not to adopt them.

### 3.3 Token Merging and Gaussian pruning

Boosting up input view number and image resolution can drastically increase the token sequence length. With 32 960$\times$540 images and patch size 8, the length can reaches about 260k, highly challenging even for linear-complexity models like Mamba. Empirically, we also find even the all-Mamba2 variant of our model runs out of memory under our highest resolution setting (see Tab. [2](#S5.T2)). To further reduce memory usage, we propose to merge the tokens in the middle of the model as well as to prune the Gaussians before rendering novel views.

Token merging achieves a fine-to-coarse effect similar to the traditional multi-level CNN encoders and effectively reduces token sequence length down to 1/4. We first reshape the token sequence from $L\!\times\!D$ back to $N\!\times\!\frac{H}{p}\!\times\!\frac{W}{p}\!\times\!D$ where $p$ is the original patch size. Then, we apply a channel-wise $2\!\times\!2$ 2D convolution with stride 2, resulting in output shape $N\!\times\!\frac{H}{2p}\!\times\!\frac{W}{2p}\!\times\!D^{\prime}$, where $D^{\prime}$ is the new token dimension that can differ from the original one. Finally, we reshape it back to $\frac{L}{4}\!\times\!D^{\prime}$ where each token now has an ‘effective’ patch size of $2p$. In our ablation studies (Tab. [2](#S5.T2)), we find our token merging design does not sacrifice much reconstruction quality, while significantly reducing memory usage and increasing training speed.

Even with token merging, our per-pixel Gaussian prediction still brings us an enormous quantity of Gaussians at the end ($\sim$17 million for 32 images with resolution 960$\times$540), which is likely more than we need for a high-quality reconstruction due to the overlap between the input view frustums. To encourage the model to use a compact set of Gaussians, we apply a punishment on the opacity of all Gaussians (detailed in Sec. [3.4](#S3.SS4)).
With the effective reduction in the number of visible Gaussians, we can thus simply prune away a certain percentage of Gaussians with low opacity.
Empirically, we find no difference in rendering quality if we prune away Gaussians with opacity below 0.001.
Beside pruning during inference, we also apply the Gaussian pruning to the 960$\times$540 resolution training.
We keep fixed-number Gaussians instead of using opacity threshold to ensure near-constant training memory usage.
O.w., the training can go out of memory for some scenes.

### 3.4 Training Objectives

Lastly, we illustrate the training objectives for Long-LRM.

Rendering loss. Following previous work (Zhang et al., ), we use a combination of Mean Squared Error (MSE) loss and Perceptual loss

$$ $\mathcal{L}_{\text{image}}=\frac{1}{M}\sum_{i=1}^{M}\left(\text{MSE}\left(\mathbf{I}^{\text{gt}}_{i},\mathbf{I}^{\text{pred}}_{i}\right)+\lambda\cdot\text{Perceptual}\left(\mathbf{I}^{\text{gt}}_{i},\mathbf{I}^{\text{pred}}_{i}\right)\right)$ (3) $$

to supervise the quality of the rendered images, where $\lambda$ is set to 0.5. While training solely with rendering loss can achieve competitive visual quality to our final model (see Sec. [5.2](#S5.SS2)), we further introduce two regularization terms to improve training stability and inference efficiency.

Depth regularization for training stability.
Training instability is a well-known curse for large-scale training.
In our task, we observe that the instability comes from the difficulty of optimizing the Gaussian positions.
With rendering loss only, the model will produce ill-posed Gaussians known as “floaters”, which does not lie on the actual 3D surface – a common issue for novel view synthesis (see the black “floaters” in Fig. [1](#S0.F1)).
To stabilize training, we add a scale-invariant depth loss

$$ $\mathcal{L}_{\text{depth}}=\frac{1}{M}\sum_{i=1}^{M}\text{Smooth-L1}\left(\mathbf{D}^{\text{da}}_{i},\mathbf{D}^{\text{pred}}_{i}\right)$ (4) $$

where $\mathbf{D}^{\text{da}}_{i}$ is the disparity map predicted by DepthAnything (Yang et al., ), and $\mathbf{D}^{\text{pred}}_{i}$ is the disparity map obtained from the predicted position of the per-pixel Gaussians. Following Yang et al. (), we normalize the disparity maps by subtracting their medians $t(d_{i})$ and then dividing by their mean absolution deviation from the medians $\frac{1}{HW}\sum|d_{i}-t(d_{i})|$. This soft depth supervision effectively helps reduce the chance of the training divergence.

Opacity regularization for inference efficiency.
Since our per-pixel prediction strategy renders a dense set of Gaussians, to encourage an efficient use of the Gaussians, we apply a small L1 regularization on the opacity

$$ $\mathcal{L}_{\text{opacity}}=\frac{1}{N}\sum_{i=1}^{N}|o_{i}|$ (5) $$

where the opacity values are between 0 and 1.
Intuitively, L1 can encourage the sparsity of the regularized terms (Tibshirani, ).
We empirically observe that adding this loss can drastically push the percentage of Gaussians with opacity above 0.001 from 99% down to around 40% (see Tab. [4](#S5.T4)).
With these near-zero opacity Gaussians, we can perform Gaussian pruning as discussed above in Sec. [3.3](#S3.SS3) and both reduce the Gaussian splatting loading time and increase the rendering speed for better model serving experience.
This regularization also enables the extreme $960\!\times\!540$ resolution training where in-training pruning is used.

Overall training loss. Our total loss is thus the rendering loss and the weighted regularization loss terms discussed above:

$$ $\mathcal{L}=\mathcal{L}_{\text{image}}+\lambda_{\text{opacity}}\cdot\mathcal{L}_{\text{opacity}}+\lambda_{\text{depth}}\cdot\mathcal{L}_{\text{depth}}$ (6) $$

where we set $\lambda_{\text{opacity}}=0.1$ and $\lambda_{\text{depth}}=0.01$.

## 4 Experiments

### 4.1 Datasets

DL3DV (Ling et al., ) is a recently published large-scale, real-world scene dataset for 3D reconstruction and novel view synthesis. It features a diverse variety of scene types, with both indoor and outdoor captures. It consists of two parts: DL3DV-10K is the training split, consisting of 10,510 high-resolution videos(^1^11We trained on the first 7K of the training split as the remaining data had not been released at the time of our experiments.), each accompanied by 200$\sim$300 keyframes with camera pose annotation (obtained from COLMAP (Schönberger et al., )); DL3DV-140 Benchmark is the test split, containing 140 test scenes. We train our model on DL3DV-10K and evaluate on the DL3DV-140 Benchmark. We also perform zero-shot inference on Tanks and Temples (Knapitsch et al., ), another real-world scene dataset for novel view synthesis. It also contains 200$\sim$300 keyframes with camera pose annotation (obtained from COLMAP) for each scene. Following previous work (Kerbl et al., ; Liu et al., ), we use the train and the truck scene from Tanks and Temples.

### 4.2 Implementation and Experiment Details

#### Architecture Details.

Our model consists of 24 blocks in total, with every 7 Mamba2 blocks followed by 1 transformer block, repeating 3 times. We start with patch size 8 and token dimension 256. We perform token merging at the beginning of the 9th block, with patch size expanded to 16 and token dimension expanded to 1024. For Mamba2 blocks, we use a state dimension 256, an expansion rate 2 and a head dimension 64. For transformer blocks, we use a head dimension 64 and an MLP dimension ratio of 4. We use the FlashAttentionV2 (Dao, ) implementation which optimizes the GPU IO utilization for long sequences.

#### Training Settings.

Directly training the model on high-resolution images is extremely inefficient; therefore we opt for an low-to-high-resolution curriculum training schedule, with three training stages, using image resolutions of $256\!\times\!256$, $512\!\times\!512$ and $960\!\times\!540$.

Specifically, in the 1st stage, training images are resized so the shorter side is 256 and then center-cropped to square.
For the training view selection, we first randomly pick a consecutive subsequence ranging from 64 frames to 128 frames, then uniformly sample 32 images as input and sample 8 images as target.
Input and target are sampled independently and thus they can overlap. We randomly shuffle the input view order with probability 0.5 and reverse the input view order also with probability 0.5.
We train with a peak learning rate of $4\textsc{e}{-4}$ and the AdamW optimizer (Loshchilov & Hutter, ) with a weight decay of $0.05$.
The learning rate is linearly warmed up in the first 2K steps and then cosine decayed.
We use a batch size of 256, and train for 60K steps.

In the 2nd stage, we resize and crop the images to $512\!\times\!512$, decrease the peak learning rate to $4\textsc{e}{-5}$, and train the model for 10K steps at batch size 64.
The view selection protocol remains the same.

In the last stage, we resize the images to $960\!\times\!540$ without square cropping, expand the view selection sampling range to the entire sequence (about 200$\sim$300 frames for DL3DV), and keep training the model for another 10K steps at batch size 64.
We perform Gaussian pruning in this stage to save GPU memory usage, where we only keep top 40% of the Gaussians ranked by opacity plus 10% randomly sampled from the rest.
We augment the FOV of the images by randomly center-cropping the images to 0.77$\sim$1.0 of the original size and resize back, in order to fit a broader range of camera models.
We optionally finetune a model with 16 images as input.

#### Evaluation Settings.

During evaluation, our goal is to reconstruct the scene captured by the entire video sequence.
Following previous work (Barron et al., ; Kerbl et al., ), we uniformly pick every 8-th image of the sequence as the test split.
From the rest of the sequence, we use $K$-means clustering (based on camera positions and directions) for choosing the input views to ensure the coverage of the scene.
The number of clusters is set of the number of input views.
We simply choose the cameras closest to the cluster centers as the input split.
We use an image resolution of $960\times 540$ during the evaluation.
We perform Gaussian pruning during evaluation by only keeping the top 50% of the Gaussians with highest opacity values, where 50% is a safe range with negligible quality loss.

### 4.3 Results

Figure: Figure 3: Qualitative comparisons between our Long-LRM and 3D Gaussian splatting (3D GS) across different scenes, reconstructed from 32 input images at $960\times 540$ resolution. The left column showcases the wide-coverage Gaussian reconstruction achieved by Long-LRM, while the right column shows results from 3D GS. Our approach maintains high-quality reconstruction with competitive or even superior PSNR values (e.g., 25.71 vs. 24.13, 28.09 vs. 27.92), demonstrating the ability to generate accurate details and fewer artifacts in challenging regions. The red ellipses highlight areas where 3D GS struggles with artifacts or inaccuracies, whereas Long-LRM produces cleaner and more photorealistic outputs, effectively handling the wide range of input views.
Refer to caption: /html/2410.12781/assets/x3.png

We encourage the readers to check our project page ([https://arthurhero.github.io/projects/llrm/](https://arthurhero.github.io/projects/llrm/)) for video and interactive renderings of our output 3D GS assets.

Our approach achieves wide-coverage scene-level 3D Gaussian splatting reconstruction from up to 32 high-resolution input images, and
to the best of our knowledge, we are the only method capable of this. While several recent works, including pixelSplat (Charatan et al., ), MVSplat (Chen et al., ), MVSGaussian (Liu et al., ) and GS-LRM (Zhang et al., ), aim to handle scene-level GS reconstruction, their models are all designed for a limited number (1$\sim$4) of input images, with pixelSplat and MVSplat even showing results only at $256\!\times\!256$ resolution.
Moreover, pixelSplat, MVSplat and MVSGaussian incorporate traditional 3D inductive biases, such as epipolar projection and cost volumes, in their model architectures, which typically expect narrow view coverage with large overlaps in input images for correspondence reasoning—making them unsuitable for our setting with many wide-coverage input views.
Additionally, naively extending pixelSplat, MVSplat, MVSGaussian and GS-LRM to train with many more input views at higher resolutions quickly lead to out-of-memory issues and cannot be easily achieved without significant modifications and further research.

**Table 1: Quantitative comparison to 3D Gaussian splatting optimization. ‘Feed-forward’ column indicates whether the method performs zero-shot feed-forward prediction. ‘Time’ refers to the total inference/optimization time for all views in the test split for each scene. The image resolution is $960\times 540$.**
| Input<br>Views | Method | Feed-<br>Forward | Time$\downarrow$ | DL3DV-140 | Tanks&Temples |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ |  |  |  |  |
| 16 | 3D GS30k | ✗ | 13min | 21.20 | 0.708 | 0.264 | 16.76 | 0.598 | 0.334 |
| Ours | ✓ | 0.7sec | 22.40 | 0.730 | 0.302 | 17.17 | 0.541 | 0.426 |  |
| 32 | 3D GS30k | ✗ | 13min | 23.60 | 0.779 | 0.213 | 18.10 | 0.688 | 0.269 |
| Ours | ✓ | 1.3sec | 23.86 | 0.775 | 0.262 | 18.20 | 0.590 | 0.375 |  |

Therefore, in this section, we focus on comparing with the original optimization-based 3D Gaussian splatting (Kerbl et al., ).
In addition, we also carefully compare with GS-LRM, which can be seen as an ablated version of our model without Mamba2 blocks, in terms of input scalability, quality and efficiency later in Sec. [5.2](#S5.SS2).
In Table [1](#S4.T1), we show the quantitave comparison results with the optimization-based 3D GS on two real-world large-scene datasets: DL3DV-140 Benchmark (Ling et al., ) and Tanks and Temples (Knapitsch et al., ).
We show results under the sparser 16 input-view setting as well as the 32 input-view setting.
We show that our model is capable of reconstructing an unseen novel scene from long-sequence input in a feed-forward manner within as little time as 1.3 seconds, $600\times$ faster than 3D GS optimization (13 minutes for 30K steps).

Reconstruction quality-wise, our feed-forward reconstruction results are comparable with 3D GS with 30K optimization steps. Our model takes lead in terms of PSNR (with the gap larger in the sparser 16-view setting: +1.2 for DL3DV-140 and +0.4 for Tanks and Temples), while 3D GS performs better in terms of LPIPS. We speculate this is because 3D GS optimization is much stronger at directly “copying” the input images into the reconstructed scene with these many optimization steps, and thus can render images with local color distribution extremely similar to the test images; however, without any prior knowledge in 3D geometry, it can easily overfit to the input views when the input is sparse (see the “floaters” in Fig. [1](#S0.F1) and [3](#S4.F3)).

We also provide a qualitative comparisons between our feed-forward reconstruction and 3D GS optimization results in Fig. [3](#S4.F3). More visualization and interactive results can be found on our website and in Appendix.

## 5 Analysis

### 5.1 Ablation Studies of Model Designs

**Table 2: Ablation studies on model architecture. We study how the model architecture affects training time and memory efficiency as well as the reconstruction quality. All variants have 24 blocks in total. {7M1T}$\mathbf{\times 3}$ refers to our “7 Mamba2 blocks + 1 Transformer block, repeating 3 times” model architecture. @9 means the token merging happens at the beginning of the 9th block. Models are trained on DL3DV-10K and evaluated on DL3DV-140 Benchmark. ^∗The 512-resolution models are finetuned from the checkpoints of their 256-resolution counterparts, and the 960-resolution from the 512-resolution checkpoints.**
| Input<br>Views | Image<br>Size | Batch Size<br>/ GPU | Train<br>Step | Block Type | Token<br>Merge | Patch<br>Size | Token<br>Dimension | #Param | Iteration<br>Time (sec) | GPU<br>Memory (GB) | PSNR$\uparrow$ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 4 | 256 | 16 | 100K | Transformer (GS-LRM) | / | 8 | 1024 | 327M | 2.3 | 44 | 21.13 |
| Mamba2 | / | 8 | 1024 | 190M | 2.8 | 35 | 19.82 |  |  |  |  |
| {7M1T}$\times 3$ | / | 8 | 1024 | 206M | 2.6 | 35 | 21.58 |  |  |  |  |
| {7M1T}$\times 3$ | @9 | 8 $\rightarrow$16 | 256 $\rightarrow$1024 | 162M | 1.9 | 20 | 21.25 |  |  |  |  |
| 32 | 256 | 4 | 60K | Transformer (GS-LRM) | / | 8 | 1024 | 327M | 14.5 | 68 | too slow |
| Mamba2 | / | 8 | 1024 | 190M | 6.0 | 70 | 24.28 |  |  |  |  |
| {7M1T}$\times 3$ | / | 8 | 1024 | 206M | 7.1 | 70 | 26.82 |  |  |  |  |
| {7M1T}$\times 3$ | @9 | 8 $\rightarrow$16 | 256 $\rightarrow$1024 | 162M | 3.5 | 25 | 25.62 |  |  |  |  |
| 32 | 512 | 1 | 10K^∗ | Transformer (GS-LRM) | / | 8 | 1024 | 327M | 50.5 | 44 | too slow |
| Mamba2 | / | 8 | 1024 | 190M | 7.4 | 62 | 24.83 |  |  |  |  |
| {7M1T}$\times 3$ | / | 8 | 1024 | 206M | 11.5 | 64 | 28.16 |  |  |  |  |
| {7M1T}$\times 3$ | @9 | 8 $\rightarrow$16 | 256 $\rightarrow$1024 | 162M | 4.0 | 23 | 27.46 |  |  |  |  |
| 32 | $960\!\times\!540$ | 1 | 10K^∗ | All other variants are out of memory. |  |  |  |  |  |  |  |
| {7M1T}$\times 3$ | @9 | 8 $\rightarrow$16 | 256 $\rightarrow$1024 | 162M | 12.6 | 53 | 27.32 |  |  |  |  |

We study how the model architecture variants scale with long input image sequence for both training efficiency and reconstruction quality.
As shown in Table [2](#S5.T2), we consider 4 experimental setups with different sequence lengths: 1. sparse low-resolution (‘Input Views’=4, ‘Image Size’=256), 2. dense low-resolution (‘Input Views’=32, ‘Image Size’=256), 3. dense high-resolution (‘Input Views’=32, ‘Image Size’=512), 4. dense ultra-resolution (‘Input Views’=32, ‘Image Size’=960$\times$540)  (^2^22Note that here the terminology of ‘sparse’, ‘dense’, ‘low’, ‘high’, ‘ultra’ are all relative. We use these terminology for simplicity and clarity.).
The results of different model architecture under the same setup are presented within a Table block (i.e., every four rows).
We study four model variants: all transformer blocks (row 1; equivalent to GS-LRM), all Mamba2 blocks (row 2), hybrid blocks but without token merging (row 3), and hybrid blocks with token merging (row 4; our final model).
All variants have 24 blocks in total.
We illustrate the number of model parameters (‘#Param’), the training iteration time, the GPU memory usage, and PSNR reconstruction metric in the last four columns.
The detailed experimental setup of this ablation study can be found in Appendix.
We next highlight the key observations.

Comparisons to Transformer.
Transformer’s performance is comparable to our model under the 4-view 256-resolution (the 1st block in Tab. [2](#S5.T2)) setting.
However, its training speed explodes for larger visual inputs, either with dense view or high resolutions.
In our 3rd experiment setup (32 views with resolution 512), the per-iteration training time with batch size=1 can go up to 50.5 seconds, which is unaffordable to train.
This is due to the quadratic time complexity of transformers.

Comparisons to Mamba2.
The Mamba2 variant shows a more manageable increase in time as the input scales up but leads to a noticeable decline in reconstruction quality compared to other variants.
For instance, in the 256-resolution, 4-view setting (1st block in Tab [2](#S5.T2)
), the Mamba2 variant exhibits a 1.8 PSNR drop compared to our hybrid model (row 3). This performance gap widens with longer sequences, reaching 2.5 PSNR for 32 views (2nd block in Tab [2](#S5.T2)) and 3.3 PSNR at 512 resolution (3rd block in Tab [2](#S5.T2)). This decrease in quality is possibly due to Mamba’s purely state-based design, which struggles to capture long-range dependencies effectively.

Effectiveness of Token Merging.
Comparing with transformer and Mamba2, our hybrid variant (third row in each block) gets the best of both worlds – the reconstruction quality (in terms of ‘PSNR’) comparable to transformer and the speed (in terms of ‘Iteration Time’) comparable to Mamba2.
On top of it, with the token merging design (last row in each block), our final model successfully reduces both time and memory usage down to $1/3$ in the $512\!\times\!512$ setting, without sacrificing too much reconstruction quality.
Token merging with Gaussian pruning also further enables scaling up to $960\times 540$ resolution with stable reconstruction, where all other variants are out-of-memory.

### 5.2 Ablation Studies of Training Objectives

**Table 3: Ablation studies on training objectives. We study how the opacity loss and the depth supervision affect the reconstruction quality as well as the Gaussian usage.**
| Input<br>Views | Image<br>Size | Loss Type | PSNR$\uparrow$ | % Gaussians w/<br>opacity$>$0.001 |
| --- | --- | --- | --- | --- |
| 4 | 256 | rendering-only | 20.43 | 99.2 |
| +opacity | 20.96 | 68.3 |  |  |
| +opacity+depth | 21.25 | 70.1 |  |  |

Impact of the regularization terms.
In Tab. [3](#S5.T3), we show the impact of the two regularization terms introduced in Sec. [3.4](#S3.SS4): the opacity loss and the depth supervision. From the table, we see that adding the opacity loss can significantly reduce the number of visible Gaussians (% of Gaussians with opacity above 0.001), while having negligible impact on model rendering performance.
The depth supervision help improve the rendering quality by guiding the “floater” Gaussians to the position of the true surfaces.
We observe it also slightly lifts the number of visible Gaussians, which is reasonable because now the model can drive the “floater” Gaussians to their correct positions instead of simply deleting them by assigning them low opacity values.
Also due to this, training with depth supervision significantly reduces the chance of gradient explosions in our experiments.

**Table 4: Gaussian usage impacted by opacity loss and input size. We observe the opacity loss can effectively reduce the number of visible Gaussians, and our model learns to adapt to a more compact set of Gaussians when the input views get denser.**
| Input<br>Views | Image<br>Size | Input Sampling<br>Range (frame) | w/ opacity loss | % Gaussians w/<br>opacity$>$0.001 |
| --- | --- | --- | --- | --- |
| 4 | $256\!\times\!256$ | 16 | ✗ | 99.2 |
| 4 | $256\!\times\!256$ | 16 | ✓ | 68.3 |
| \hdashline32 | $256\!\times\!256$ | $64\sim 128$ | ✓ | 41.8 |
| 32 | $512\!\times\!512$ | $64\sim 128$ | ✓ | 34.1 |
| 32 | $960\!\times\!540$ | $200\sim 300$ | ✓ | 33.3 |

Impact of opacity loss on Gaussian Usage.
In Tab. [4](#S5.T4), we show how the opacity loss and the input size affects the Gaussian usage (percentage of Gaussians with opcacity $>0.001$).
Comparing row-1 and row-2, we observe that the opacity regularization loss introduced in Sec. [3.4](#S3.SS4) can effectively reduce the number of ‘high’-opacity Gaussians shown in the last column.

Furthermore, our model learns to adaptively use a different number of Gaussians when the input varies (as shown in Tab. [4](#S5.T4)).
As the image resolution increases (hence more per-pixel Gaussians predicted), the chance that multiple pixels can be covered by the same Gaussian increases as well, and thus the percentage of Gaussian usage decreases.
However, as the sampling range (i.e., the maximum difference in frame indices of the input views, shown as ‘Input Sampling Range’) increases, the overlap between input views decreases, and thus the model needs to retain more Gaussians to keep reconstruction quality, resulting in negligible drop in Gaussian usage in the last row.

## 6 Conclusions

In this work, we introduce Long-LRM, a novel model for fast and scalable 3D Gaussian splatting reconstruction. By combining Mamba2 and transformer blocks, along with token merging and Gaussian pruning, Long-LRM can instantly reconstruct a wide-coverage 3D GS scene from 32 images at a high resolution of $960\times 540$ in just 1.3 seconds, leading to high rendering quality comparable to optimization-based methods such as 3D Gaussian splatting. Our approach is the first feed-forward GS solution for wide-coverage scene-level reconstruction.

## Acknowledgements

We thank Nathan Carr and Kalyan Sunkavalli for their support and helpful discussions. We thank Lu Ling for the support in using the DL3DV dataset.

## Appendix A More Results

We show more results of our Long-LRM on large-scale scenes using 32 wide-coverage input views at $960\times 540$ image resolution in Fig. [4](#A4.F4).
For more visual results with rendered long-trajectory videos, please refer to our project webpage ([https://arthurhero.github.io/projects/llrm/](https://arthurhero.github.io/projects/llrm/)).

## Appendix B Other Implementation Details

Following GS-LRM (Zhang et al., ), we normalize the camera poses by setting the world coordinate frame to the mean camera pose of the input views and scaling all input camera locations to fit within the $[-1,1]^{3}$ bounding box.

When rendering, we set the near plane of the splatting frustum at 0.01.
We found that normalizing the camera poses causes Gaussians near the camera to be cut off if the default value of 0.2 from 3D GS (Kerbl et al., ) is used.
However, omitting depth supervision makes the training unstable, so we retain the near plane at 0.2 for the ablation studies without the depth supervision in Tab. [3](#S5.T3).

## Appendix C Experimental Details for Model Architecture Ablation Studies

In Table [2](#S5.T2), we present the model architecture ablation studies with different length of input sizes.
We train all variants on DL3DV-10K and evaluate on DL3DV-140.
The number of training steps are empirically decided based on the model convergence, and set to be the same.
We study the model behavior under four different settings: 4 input views at $256\!\times\!256$, 32 input views at $256\!\times\!256$, and 32 input views at $512\!\times\!512$, and our extreme setting: 32 input views at $960\!\times\!540$.

For these ablation studies, we use a shorter frame range during evaluation for fair comparisons among each experiments.
In details, we choose the first 96 frames from the original video frame sequence, then uniformly sample 8 test views.
The training 4 to 32 training views are then uniformly sampled from the rest views, i.e., not overlapping to the testing views.
We kept the same set of training and testing views for different experimental setups.
The input images are resized and center-cropped to squares except for the last row.

## Appendix D Limitations

We now briefly discuss the limitations. While we successfully scaled the model to support 32 high-resolution views and achieved wide-coverage large-scale GS reconstruction, we observed only marginal performance improvements when further increasing the number of input views. Specifically, increasing the input to 64 views only lead to less than 1 dB PSNR improvement. Notably, 64 high-res images correspond to extremely long sequences, exceeding 500k in context length, which presents a significant challenge for current sequence processing models. Addressing this limitation will require future work to better manage ultra-long sequences.
Additionally, since the entire DL3DV training set contains images with a fixed wide field of view (FOV), we found that our model struggles to generalize on test sets with significant FOV variations (e.g., the MipNeRF360 dataset with a much smaller FOV). We suspect this limitation is due to the use of Mamba2 blocks, as differing FOVs can alter the meaning of tokens at different positions. Developing models that can generalize effectively across varying FOVs may require more diverse datasets with a range of various FOVs, at a scale similar to DL3DV.

Figure: Figure 4: Demonstration of our Long-LRM’s novel view synthesis capabilities. The left column illustrates the wide-coverage Gaussian reconstruction achieved by our model, while the right columns show high-quality synthesized novel views from different perspectives. These examples demonstrate Long-LRM’s ability to handle diverse and complex scenes, accurately reconstructing fine-level details, and generating photorealistic views from multiple angles, effectively capturing both geometric and appearance variations across different scenes.
Refer to caption: /html/2410.12781/assets/x5.png

## Peer Reviews

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: While the work on token merging and Gaussian pruning for memory efficiency is valuable, these engineering optimizations better fit computer vision venues like CVPR. Despite the technical advances,  could you justify how this work aligns with ICLR's focus on fundamental machine learning methodology rather than computer vision conferences?
soundness: 2
strengths: 1. Enhance feed-forward scene reconstruction methods, eg, GS-LRM to more input views.

2. The usage of hyrbid network of Mamba and transformer is reasonable for handling extreme long-sequence tokens, though it is not the first paper in this field that introduce Mamba.

3. Practical solutions for memory efficiency through token merging and Gaussian pruning, enabling scaling to high resolutions (960x540) where other variants fail.

4. The ablation study is comprehensive, well demonstrating the effectiveness of each component, with clear metrics on performance gains.
summary: This paper introduces Long-LRM, a feed-forward model for large-scale 3D Gaussian reconstruction that can process 32 high-resolution (960×540) input images in just 1.3 seconds on a single A100 GPU. The key innovation lies in its hybrid architecture combining Mamba2 and transformer blocks, along with efficient token merging and Gaussian pruning strategies to handle long sequences and memory constraints. The model achieves 600× faster reconstruction than optimization-based 3D Gaussian Splatting while maintaining comparable or better quality, as demonstrated through comprehensive evaluations on DL3DV and Tanks and Temples datasets.
weaknesses: 1. Lack of novelty. The core contribution of this paper seems a combination of GS-LRM and Hamba, Gamba  and MVGamba. 

2. The lack of discussion on the above Mamba-based 3D reconstruction models, which have been publicly available more than half years, is not acceptable.

3. While this paper presents several practical innovations in memory optimization, it may be more suitable for computer vision conferences rather than ICLR.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 3
questions: please refer to the weakness part.
soundness: 3
strengths: 1. Extends the application of feed-forward 3D scene reconstruction to longer-range inputs.
2. Sound network architecture design by combining transformers and Mamba2 to process long token sequences.
3. Applies a token merging module to reduce computational overhead for processing long-range input views.
4. The author provides justification for using Mamba in Table 2, although the comparison with GS-LRM is somewhat unfair.
summary: This paper proposed a generalizable 3D reconstruction framework for a long range of input images. 3D Gaussian Splatting is used as the 3D representation like many previous works. The network architecture is design as mixture of Mamba2 and transformer layers to process input tokens with long length.  The whole model is trained in single stage and can reconstruct large scale 3D secenes on DL3DV-140, Tanks and Template datasets.
weaknesses: 1. Insufficient justification for using Mamba. GS-LRM claims it can accept arbitrary input view numbers by downsampling images with large patch sizes to shorten the overall token length for global attention. The features after attention can then be upsampled to predict a large number of Gaussians. However, in Table 2, the authors provide the same patch size for both the 7M1T and GS-LRM architectures, leading to an unfair comparison.

2. Why not cost volumes and abadon 3D inductive biases. Although the authors have argued that methods like MVSplat are prone to out-of-memory (OOM) issues, these challenges are largely engineering problems that can be addressed with techniques like FlashAttention or through lightweight network architecture design. The authors need to clarify this point; otherwise, this work may mislead the feed-forward 3D scene reconstruction community.

3. Lack of discussion on 3D reconstruction works utilizing Mamba. This work seems to overlook prior research utilizing Mamba for 3D reconstruction, such as Hamba, Gamba, and MVGamba, which have been publicly available for over six months. Discussing these related works is necessary to emphasize the motivation for this study.

4. Limited technical contribution and insight. The technical contributions of this work are quite limited, as are its insights. It mainly extends previous 3D reconstruction efforts that use Mamba for scene reconstruction. Notably, combining Mamba and transformer blocks cannot be considered novel, as this setup was proposed in the Mamba v2 paper and has been widely adopted in various Vision Mamba works with Mamba v2. When evaluating the technical contributions, it is challenging to provide a positive rating, as nearly all modules in this paper have been widely used in numerous feed-forward 3D object reconstruction studies over the past year. Additionally, the claims regarding cost volumes contradict established practices in feed-forward 3D scene reconstruction.

Based on the weaknesses outlined above, I think this paper is marginally below the acceptance threshold.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: 1.Is it able to seamlessly concat all sets of gaussians inferred by your models for large scale scenes which need hundreds of images? If so, how is it compared with city-scale reconstruction methods like CityGaussian and Octree-GS: Towards Consistent Real-time Rendering with LOD-Structured 3D Gaussians, which are designed for real large scale scene reconstruciton.
soundness: 3
strengths: 1.Introducing a method able to infer the 3DGS for wide-coverage scenes.

2.Utilize Mamba2 architecture to model the long token relations.
summary: They propose a generalizable 3D Gaussian reconstruction model that can reconstruct a wide -coverage scene from a long sequence of input images with Mamba2 blocks. Some validation results shows the effeciveness compared with original 3DGS.
weaknesses: 1.The comparison is not enough. Only compared with naive 3DGS. There are recent 3DGS/NeRF variants designed for large scale scene modeling: Zip-NeRF: Anti-Aliased Grid-Based Neural Radiance Fields, Scaffold-GS: Structured 3D Gaussians for View-Adaptive Rendering, Mip-Splatting: Alias-free 3D Gaussian Splatting.

2.Despite of the inference speed, it shows in the videos the floaters appear without further regularizations.

3.They main contribution is to use Mamba2 for long sequence modeling, which limits the technical contribution of the paper.

4.It is better to show the NVS comparison under sparse view setting compared with generalizable 3DGS methods like MVsplat and pixelSplat.

5.The method only shows the NVS results, it would be better to show some surface reconstruction results since with the development of "2DGS" and "High-quality Surface Reconstruction using Gaussian Surfels". Nowadays surface reconstruction with Gaussians already achieves very good results.

6.No regularization for aliasing effect is proposed.

Meta-review: This paper proposes a feed-forward model for large-scale 3D Gaussian reconstruction that can process 32 high-resolution (960×540) input images in 1.3 seconds on a single A100 GPU. The key innovation lies in its hybrid architecture combining Mamba2 and transformer blocks, along with efficient token merging and Gaussian pruning strategies to handle long sequences and memory constraints.  Reducing memory consumption through token merging and Gaussian pruning should be appreciated.  Also, 600x faster reconstruction performance than optimization-based 3D Gaussian Splatting is significant.  On the other hand, the reviewers raised concerns regarding limited novelty, insufficient discussion to justify the proposed model, and insufficient validation.  Reviewer 1Xmy was concerned with whether the presented work is aligned with the scope of ICLR.  In the rebuttal, the authors have provided additional experiments to address the concerns on validation and argued the justification for using Mamaba and differences from prior Mamba-based 3D reconstruction methods.  Possibility of directly merging Gaussians and positioning of the paper in relation to Scaffold-GS are further discussed between the authors and the reviewers.  In the end, two reviewers are negative while one reviewer is positive for the paper.  Regarding the concern on the venue selection, AC acknowledges ICLR is appropriate.  Since the size of the community is rapidly growing and the scope of ICLR is expanding, not restricted to fundamental machine learning methodology, this paper should not be rejected because of out-of-scope.  On the other hand, although the authors claim that this work targets scalability of large scene-level reconstruction with long-sequence, arguments on scalability seem not sufficient.  There should be argument that 32 input images are enough to be long-sequence.  In fact, Reviewer K9N5 raised concern on the possibility of real large-scale scene reconstruction.  Through the author-reviewer discussion, it turned out that handling even more input images (say, hundreds) is not possible and needs further work.  At least in-depth discussion toward real large-scale reconstruction should be addressed. Otherwise, the paper cannot be scientifically solid in the context. Providing comparison with Mamba-based 3D reconstruction methods (which may need some post-processing to adjust the same scale) will make the paper stronger.  Reviewer K9N5 also suggested to combine 3D GS variants such as Scaffold-GS into the proposed method, which seems to achieve new SOTA; however, the authors just excuse that the contribution of Scaffold-GS is orthogonal and complementary.  The usage of hybrid network of Mamba and transformer has brought significant speed-up with on-par quality, but offline setting is not attractive for the applicability of the method in real scenarios. AC finds room to strengthen the method to be solid for real large-scale scene reconstruction.  On balance, the remaining concerns outweigh the current technical contributions and the paper would benefit from more work.  For this, the paper cannot be accepted to this conference.

Decision: Reject