LingBot-Map: Streaming 3D Reconstruction Model
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.
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.
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
Frequently Asked Questions
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.
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.
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.
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.
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.
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.
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.
