Noureddine RAMDI / Fast3R: scalable multi-view 3D reconstruction with a single forward pass

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
985 Words
github-stars 3d-reconstruction computer-vision pytorch transformers multiview machine-learning

facebookresearch/fast3r

Fast3R tackles a persistent bottleneck in multi-view 3D reconstruction: the need to perform iterative pairwise matching between images, which scales quadratically and becomes impractical beyond a few dozen views. Instead, Fast3R processes over a thousand unordered images simultaneously in a single forward pass, collapsing what used to be an O(n²) operation into a single batched inference. This architectural shift offers a pathway to scalable and efficient 3D reconstruction pipelines.

what fast3r does: single-forward-pass multi-view 3d reconstruction

Fast3R, developed by Meta’s FAIR team and presented at CVPR 2025, extends the DUSt3R framework by enabling dense 3D reconstruction from large unordered sets of images in one go. The model uses a ViT-Large (Vision Transformer) architecture augmented with FlashAttention for efficient large-scale attention computation and a custom multi-view attention mechanism to fuse information across multiple views.

The core output of Fast3R is a dense per-pixel pointmap representing 3D scene geometry, along with joint camera pose predictions. Unlike traditional pipelines like COLMAP that rely on iterative pairwise feature matching and bundle adjustment, Fast3R’s feed-forward approach directly regresses dense depth and pose from a massive image set.

This repo supports a wide variety of datasets and benchmarks including DTU, 7-Scenes, CO3D, RealEstate10K, Tanks and Temples, ETH-3D, and ScanNet, demonstrating its applicability across indoor and outdoor scenes with diverse complexity.

The pipeline includes:

  • A Gradio demo for interactive visualization of 3D reconstructions and camera poses from image uploads or videos.
  • A clean, modular PyTorch inference API accessible via Hugging Face model loading.
  • Hydra-based training support with multi-node Slurm integration for scalable training.
  • A LightningModule wrapper that manages PnP-based pose estimation and focal length recovery from predicted pointmaps.

The architecture and codebase are designed for extensibility, allowing users to import Fast3R as a standard PyTorch module for custom projects.

what sets fast3r apart: large-scale multi-view attention and flashattention

Fast3R’s main technical strength lies in its approach to multi-view fusion. Traditional methods process image pairs or small groups iteratively, which limits scalability. By contrast, Fast3R employs a multi-view attention mechanism that simultaneously attends across 1000+ unordered images, capturing geometric and photometric consistency in a single forward pass.

The use of ViT-Large provides a powerful transformer backbone that can encode image features across views. FlashAttention, a more memory-efficient and faster implementation of attention, is critical here — it enables handling the huge attention matrices that come with processing thousands of images without running out of memory or incurring prohibitive compute costs.

The tradeoff is complexity and compute requirement: running a ViT-Large model with FlashAttention on thousands of images demands significant GPU memory and compute power, likely requiring high-end hardware setups. However, this design eliminates the iterative matching bottleneck and bundle adjustment steps, simplifying the inference pipeline and enabling end-to-end differentiability.

Code quality in the repo is pragmatic and modular. The LightningModule wrapper encapsulates pose estimation logic cleanly, and the use of Hydra for configuration offers flexible experiment management. The inference API is straightforward and integrates with Hugging Face’s model hub, easing adoption.

quick start: installing and running the demo

The repo provides clear instructions for installation and demo execution:

# install PyTorch (adjust cuda version according to your system)
conda install pytorch torchvision torchaudio pytorch-cuda=12.4 nvidia/label/cuda-12.4.0::cuda-toolkit -c pytorch -c nvidia

# install requirements
pip install -r requirements.txt

# install fast3r as a package (so you can import fast3r and use it in your own project)
pip install -e .

Note the warning: do not install the cuROPE module as with DUSt3R; it interferes with Fast3R’s prediction.

To launch the interactive Gradio demo, run:

python fast3r/viz/demo.py

This command downloads pre-trained model weights and config automatically from the Hugging Face model hub. The demo allows uploading images or videos and visualizes 3D reconstruction results along with camera pose estimations.

The demo script also serves as a usage example for inference.

For integration in your own projects, you can import the Fast3R class directly:

import torch
from fast3r.models.fast3r import Fast3R

model = Fast3R()
# load pretrained weights, run inference etc.

verdict: for researchers and practitioners scaling multi-view 3d

Fast3R offers a fresh architectural take on multi-view 3D reconstruction that scales to image sets 10x or more larger than typical pipelines. Its single-forward-pass design overcomes the quadratic scaling bottleneck inherent in pairwise matching.

That said, the approach demands substantial GPU resources and is specialized for scenarios where you have hundreds or thousands of unordered images. If your use case involves smaller image sets or environments with limited compute, classical methods like COLMAP or DUSt3R might remain more practical.

The codebase is well-structured for extension and experimentation, making it a solid starting point for researchers and engineers interested in pushing large-scale dense 3D reconstruction forward. The integration with Hugging Face and the Gradio demo add practical value for quick testing and visualization.

In production scenarios where latency and hardware cost are concerns, the tradeoff between simplicity of inference and heavy compute should be carefully evaluated. Still, Fast3R’s approach is worth understanding for anyone working on scalable multi-view geometry, especially as hardware continues to improve.

→ GitHub Repo: facebookresearch/fast3r ⭐ 1,570 · Python