TopGit
GitHub Repo Review

LingBot-Map: Streaming 3D Reconstruction Model

Robbyant/lingbot-map
LTopGit review image for Robbyant/lingbot-map
Review by Topgit.dev for Robbyant/lingbot-map, with GitHub repository stats and README context.
Quick verdict

LingBot-Map is worth reaching for when you want streaming 3D reconstruction from a video or image folder without running a full SLAM pipeline or per-scene optimization: its Geometric Context Transformer processes frames feed-forward and outputs a point cloud in one pass. Skip it if you need published benchmarks before committing — the README claims strong results but lists no scores, and the offline renderer needs CUDA extras like Kaolin.

Stars
★ 16.4k
Forks
⑂ 1.8k
Language
Python
License
Apache-2.0
Topic
Updated
Aug 2026
Homepage
GitHub

Understanding LingBot-Map

LingBot-Map is a feed-forward 3D foundation model from the Robbyant Team that reconstructs 3D scenes from streaming video or image sequences. Instead of iteratively optimizing a scene like classic SLAM or bundle adjustment, its Geometric Context Transformer combines anchor context, a pose-reference window, and trajectory memory to predict geometry and camera pose in a single forward pass, at roughly 20 FPS on 518×378 images.

Core Capabilities

  • Geometric Context Transformer unifies coordinate grounding, dense geometric cues, and drift correction through anchor context, a pose-reference window, and trajectory memory — all in one streaming architecture.
  • Feed-forward inference with paged KV cache attention holds ~20 FPS at 518×378 resolution on sequences beyond 10,000 frames, per the README.
  • Keyframe interval and windowed inference modes (--mode windowed, --window_size, --overlap_keyframes) extend the model past its ~320-frame training range for very long recordings.
  • Three checkpoints ship on Hugging Face and ModelScope: lingbot-map-long for large scenes, lingbot-map as the balanced default used in the paper, and lingbot-map-stage1, which can load into VGGT for bidirectional inference.
  • Offline rendering pipeline (demo_render/batch_demo.py) turns a video or image folder into a headless point-cloud flythrough MP4 without the interactive viewer.
  • Sky masking uses an auto-downloaded ONNX segmentation model to strip sky points from outdoor reconstructions, with masks cached to disk between runs.
  • Evaluation scripts cover benchmarks including KITTI, Oxford Spires, VBR, Droid-W, TUM-D, 7-scenes, ETH3D, Tanks and Temples, and NRGBD.
How this repository's GitHub stars have grown over time. Source: star-history.com.View the star history

Setting Up LingBot-Map

Installation is documented step by step. Create a conda environment with Python 3.10, then install PyTorch 2.8.0 with torchvision 0.23.0 against CUDA 12.8 (`pip install torch==2.8.0 torchvision==0.23.0 --index-url https://download.pytorch.org/whl/cu128`) — this version is recommended because NVIDIA Kaolin, needed for the batch renderer, ships prebuilt wheels only for torch-2.8.0_cu128. Install the package itself with `pip install -e .`, then add FlashInfer (`pip install --index-url https://pypi.org/simple flashinfer-python`) for paged KV cache attention; without it the model falls back to PyTorch's native SDPA attention via `--use_sdpa`. Visualization extras are optional: `pip install -e ".[vis]"`. The offline rendering pipeline needs more: `pip install -e ".[vis,render]"` for open3d and pyyaml, onnxruntime-gpu for batched sky masking, Kaolin built against the same torch/CUDA combo, ffmpeg, and a local build step (`cd demo_render/render_cuda_ext && python setup.py build_ext --inplace`) for its CUDA extensions.

Strengths

  • Feed-forward inference avoids per-scene optimization — one forward pass produces geometry and pose instead of an iterative solve.
  • Keyframe interval and windowed inference give a concrete mechanism, not just a flag, for extending past the ~320-frame training range to sequences of thousands of frames.
  • Three ready-to-download checkpoints (lingbot-map, lingbot-map-long, lingbot-map-stage1) cover different scene-length trade-offs out of the box.
  • Offline rendering pipeline and interactive viser viewer are both included, so you're not left writing your own visualization layer.
  • Apache-2.0 licensing imposes no copyleft or commercial-use restriction.

Known Constraints and Performance Notes

  • No quantitative benchmark numbers are published in the README — it claims ' ' results on the listed datasets but shows no scores, so you can't compare accuracy without running the eval scripts yourself.
  • The offline rendering pipeline has a heavier, more fragile dependency chain than the core model: Kaolin only has prebuilt wheels for the torch-2.8.0/CUDA-12.8 combo, and other combinations require building it from source with a local CUDA toolkit.
  • Inference range is bounded by training data: the model does not reset state by default, and beyond the training-time distance you may see pose collapse and need to switch to windowed mode manually.
  • The README documents CUDA-based GPU inference only; no CPU-only path or non-NVIDIA GPU support is mentioned.
  • A 'stronger model that supports longer sequences' is listed as 'coming soon' — the current checkpoints are the only ones available now.

Other 3D Reconstruction Approaches

VGGT — the bidirectional model that LingBot-Map's stage-1 checkpoint is designed to load into, per the README, if you want non-streaming reconstruction instead of a feed-forward streaming pass.COLMAP — classic structure-from-motion and multi-view stereo pipeline; slower and iterative rather than feed-forward, but doesn't require a GPU foundation-model checkpoint.DROID-SLAM — a deep-learning SLAM system built around iterative optimization rather than a single feed-forward pass.Nerfstudio — its viser viewer library is what LingBot-Map's interactive demo runs on; useful if you want a broader NeRF/3D toolkit instead of just the reconstruction model.

Frequently Asked Questions

What is LingBot-Map used for?

LingBot-Map is used for reconstructing 3D scenes — geometry and camera poses — from streaming video or a folder of images, using a single feed-forward pass instead of iterative optimization.

What kind of 3D reconstruction does LingBot-Map perform?

LingBot-Map performs streaming 3D reconstruction: it outputs a point cloud and camera trajectory frame by frame through its Geometric Context Transformer, rather than optimizing a scene offline like classic SLAM or bundle adjustment.

How does LingBot-Map handle long video sequences?

LingBot-Map uses a keyframe interval to thin its KV cache for sequences past its ~320-frame training range, and a windowed inference mode (--mode windowed) with configurable window size and keyframe overlap for sequences beyond roughly 3,000 frames.

What are the system requirements for LingBot-Map?

LingBot-Map needs a CUDA-capable NVIDIA GPU, Python 3.10, PyTorch 2.8.0 with CUDA 12.8, and ideally FlashInfer for paged KV cache attention; the offline rendering pipeline additionally requires Kaolin, open3d, and ffmpeg.

Is LingBot-Map suitable for production use?

The README doesn't make a production claim for LingBot-Map — it ships as a research release with an open TODO list, ongoing bug fixes to its KV cache handling, and a 'coming soon' checkpoint for longer sequences.

What license is LingBot-Map released under?

LingBot-Map is released under the Apache-2.0 license, so you can use, modify, and self-host it freely.

Best use cases

  • Prototyping streaming 3D reconstruction from a phone or camera video without building a SLAM pipeline from scratch.
  • Batch-rendering long indoor or outdoor walkthroughs (the README's example runs to roughly 25,000 frames) into a point-cloud flythrough MP4 via the offline pipeline.
  • Evaluating streaming reconstruction methods against public benchmarks such as KITTI and Oxford Spires using the released evaluation scripts.
  • Reconstructing scenes from video generated by LingBot-World (the README's companion world model) to inspect its output geometry.
  • Loading the stage-1 checkpoint into VGGT for bidirectional, non-streaming inference when you don't need the streaming property.

How to use

Download one of three checkpoints from Hugging Face or ModelScope (robbyant/lingbot-map) — lingbot-map-long, lingbot-map, or lingbot-map-stage1 — then point demo.py at it: `python demo.py --model_path /path/to/lingbot-map.pt --image_folder example/courthouse --mask_sky`. That launches an interactive viser viewer at http://localhost:8080 using the three bundled example scenes (courthouse, university, loop). For sequences past roughly 320 frames — the model's video RoPE training range — set `--keyframe_interval` to thin the KV cache, or switch to `--mode windowed --window_size 128` for anything past 3,000 frames. Sequences too long for the browser viewer, like the README's ~25,000-frame, 13-minute indoor walkthrough, go through `demo_render/batch_demo.py` instead, which renders a headless point-cloud flythrough MP4 directly from a video file or image folder using the same checkpoint.

Who should try it — and who should skip

Try LingBot-Map if you're prototyping streaming 3D reconstruction from video or photo sequences on an NVIDIA GPU and want a single feed-forward pass instead of assembling a SLAM or SfM pipeline from scratch — the three example scenes and viser viewer get you to a first result fast. Skip it if you need CPU-only inference, published accuracy numbers before you commit GPU time, or a mature production deployment story: this reads as a research release with an active TODO list and a 'coming soon' checkpoint, not a finished product.

Source & attribution

Based on the Robbyant/lingbot-map GitHub repository (github.com/Robbyant/lingbot-map).

GitHub data · last synced Aug 5, 2026Reviewed by Henry
Back to TopGit

Is lingbot-map worth your time?

ChatGPT, Claude and Perplexity can all read this page. Ask one of them what it makes of lingbot-map.

GitHub