# Core Dependencies for lingbot-map: Complete Installation Guide

> Discover the core dependencies for lingbot-map including Python PyTorch Open3D NumPy SciPy and CMake Get the complete installation guide for this Robbyant GitHub project

- Repository: [Robbyant/lingbot-map](https://github.com/Robbyant/lingbot-map)
- Tags: installation-guide
- Published: 2026-07-19

---

**The lingbot-map repository requires Python ≥3.8, PyTorch, Open3D, NumPy, SciPy, and CMake ≥3.18 with pybind11 for its optional CUDA extensions, as declared in [`pyproject.toml`](https://github.com/Robbyant/lingbot-map/blob/main/pyproject.toml) and [`demo_render/render_cuda_ext/setup.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/render_cuda_ext/setup.py).**

The lingbot-map repository is a Python-based visual-SLAM and mapping toolkit that builds on a small set of well-maintained third-party libraries. Understanding the core dependencies for lingbot-map is essential for successfully running the mapping pipeline, benchmark suite, and optional GPU-accelerated rendering extensions on Linux-based development environments.

## Runtime Dependencies in pyproject.toml

The primary runtime requirements are declared in the root [`pyproject.toml`](https://github.com/Robbyant/lingbot-map/blob/main/pyproject.toml) file. These packages constitute the minimal stack required to execute the core mapping algorithms and visualization tools.

- **Python ≥3.8**: The baseline runtime language for the entire toolkit.
- **PyTorch**: Provides tensor operations and GPU-accelerated neural-network components for depth estimation tasks.
- **Open3D**: Handles 3-D point-cloud processing, mesh construction, and visualization utilities throughout the codebase.
- **NumPy**: Supplies fundamental array mathematics used in geometric transformations and data structures.
- **SciPy**: Offers linear-algebra utilities and optimizations for registration algorithms and pose-graph solvers.
- **tqdm**: Renders progress-bar feedback for long-running loops in benchmark runs and dataset processing.
- **Matplotlib**: Enables plotting of metrics and visual debugging of maps and trajectories.
- **Pillow**: Manages image loading and conversion for the demo rendering pipeline.
- **PyYAML**: Parses configuration files located under `demo_render/config/`.
- **Click**: Powers the command-line interface for benchmark utilities in [`benchmark/run.py`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/run.py) and [`benchmark/evaluate.py`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/evaluate.py).
- **imageio**: Handles reading and writing of video frames used by the RGB-D demo renderer.

## Build Tools for CUDA Extensions

Optional GPU acceleration requires compiling native extensions located in `demo_render/render_cuda_ext/`. The build system relies on additional tooling specified in [`demo_render/render_cuda_ext/setup.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/render_cuda_ext/setup.py).

- **CMake ≥3.18**: Required to configure the build system for the CUDA extensions.
- **pybind11**: Provides the Python bindings for C++ CUDA kernels such as `voxel_morton`, enabling fast Morton encoding on the GPU from Python code.

## Installing the Dependency Stack

To install the core dependencies for lingbot-map, clone the repository and use pip with the provided configuration files.

First, install the primary runtime packages:

```bash
pip install torch open3d numpy scipy tqdm matplotlib pillow pyyaml click imageio

```

Then, install the package itself along with any remaining requirements:

```bash
pip install .

```

For the optional CUDA extensions, ensure CMake ≥3.18 is installed on your system, then build the extensions:

```bash
cd demo_render/render_cuda_ext
python setup.py build_ext --inplace

```

Additional runtime packages specific to the demo rendering pipeline are listed in [`demo_render/requirements.txt`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/requirements.txt) and can be installed via:

```bash
pip install -r demo_render/requirements.txt

```

## Dependency Usage Examples

The following examples demonstrate how lingbot-map leverages its core dependencies in practice.

### Basic Mapping with Open3D and PyTorch

This example shows the integration of Open3D for geometry handling and PyTorch for internal tensor operations when building a map from an RGB-D sequence using the `Mapping` class defined in [`lingbot_map/__init__.py`](https://github.com/Robbyant/lingbot-map/blob/main/lingbot_map/__init__.py):

```python
import lingbot_map as lm
import open3d as o3d
import numpy as np

# Load an example RGB-D dataset (the repository ships a few PNG sequences)

rgb = o3d.io.read_image("example/university/000320.png")
depth = o3d.io.read_image("example/university/000321.png")
rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(rgb, depth)

# Initialise the mapper (uses PyTorch tensors internally)

mapper = lm.Mapping()
mapper.integrate(rgbd)

# Retrieve the current point cloud

pcd = mapper.get_point_cloud()
o3d.visualization.draw_geometries([pcd])

```

### CLI Benchmark Utilities

The benchmark suite relies on Click for its command-line interface, as implemented in [`benchmark/run.py`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/run.py):

```bash

# CLI entry point provided by Click in `benchmark/run.py`

python -m benchmark.run --config demo_render/config/indoor.yaml --output results/

```

### CUDA Extension with pybind11

For GPU-accelerated voxel operations, the repository uses pybind11-bound CUDA kernels. This requires the build tools mentioned above:

```python
from render_cuda_ext.voxel_morton import voxel_hash
import torch

coords = torch.randint(0, 256, (1000, 3), dtype=torch.int32, device='cuda')
hashes = voxel_hash(coords)      # Fast Morton encoding on the GPU

print(hashes[:10])

```

## Summary

- The core dependencies for lingbot-map are declared in [`pyproject.toml`](https://github.com/Robbyant/lingbot-map/blob/main/pyproject.toml) and include PyTorch, Open3D, NumPy, and SciPy for the computational pipeline.
- **Python ≥3.8** is the minimum required version for running the toolkit.
- Optional GPU acceleration requires **CMake ≥3.18** and **pybind11** to compile the CUDA extensions in `demo_render/render_cuda_ext/`.
- Utility dependencies such as **Click**, **tqdm**, and **Matplotlib** support the benchmarking and visualization workflows.
- Install the full stack using `pip install .` followed by manual compilation of CUDA extensions if GPU support is needed.

## Frequently Asked Questions

### What is the minimum Python version required for lingbot-map?

The repository requires **Python ≥3.8** as the baseline runtime language, as specified in the [`pyproject.toml`](https://github.com/Robbyant/lingbot-map/blob/main/pyproject.toml) file. This ensures compatibility with the type hints and async features used throughout the codebase.

### Do I need CUDA to run lingbot-map?

No, CUDA is optional. The core mapping pipeline runs entirely on CPU using PyTorch and NumPy. However, if you want to use the GPU-accelerated voxel operations (such as the `voxel_morton` kernel), you must compile the CUDA extensions using CMake ≥3.18 and pybind11 as defined in [`demo_render/render_cuda_ext/setup.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/render_cuda_ext/setup.py).

### Where are the core dependencies declared?

The primary runtime dependencies are listed in the root **[`pyproject.toml`](https://github.com/Robbyant/lingbot-map/blob/main/pyproject.toml)** file. Additional packages specific to the demo rendering pipeline are cataloged in **[`demo_render/requirements.txt`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/requirements.txt)**, while build dependencies for the CUDA extensions are specified in **[`demo_render/render_cuda_ext/setup.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo_render/render_cuda_ext/setup.py)**.

### How do I install the optional CUDA extensions?

First ensure CMake ≥3.18 is installed on your Linux system. Then navigate to `demo_render/render_cuda_ext/` and run `python setup.py build_ext --inplace` to compile the pybind11-bound kernels. This enables the `render_cuda_ext` module imports used for fast Morton encoding on the GPU.