# PyTorch and CUDA Version Requirements for LingBot-Map: Complete Compatibility Guide

> Ensure LingBot-Map compatibility by confirming PyTorch and CUDA version requirements. Discover the ideal setup with PyTorch 2.8.0 and CUDA 12.8 or a fallback option.

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

---

**LingBot-Map requires PyTorch 2.8.0 with CUDA 12.8 for full functionality, though PyTorch 2.5.1 with CUDA 12.1 serves as a fallback for legacy environments that cannot upgrade.**

LingBot-Map is a PyTorch-based spatial mapping framework that leverages CUDA-accelerated GPU computing for its rendering pipeline. According to the Robbyant/lingbot-map repository, strict version constraints apply specifically due to the batch-renderer's dependency on NVIDIA Kaolin pre-built wheels.

## Recommended PyTorch and CUDA Versions

The officially supported stack centers on **PyTorch 2.8.0** paired with **CUDA 12.8**, as documented in [[`README.md`](https://github.com/Robbyant/lingbot-map/blob/main/README.md) line 102](https://github.com/Robbyant/lingbot-map/blob/main/README.md#L102).

This combination uses the `cu128` wheel index:

```bash
pip install torch==2.8.0 torchvision==0.23.0 --index-url https://download.pytorch.org/whl/cu128

```

The **CUDA 12.8** requirement is non-negotiable for the batch-rendering pipeline because NVIDIA Kaolin only provides pre-built wheels for the `torch-2.8.0_cu128` combination. Attempting to use alternative PyTorch versions forces compilation of Kaolin from source.

## Legacy Configuration: PyTorch 2.5.1 with CUDA 12.1

For environments that cannot upgrade to CUDA 12.8, the repository maintains an alternative configuration. The benchmark setup script at [[`benchmark/envs/install_lingbot_map.sh`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh) line 49](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh#L49) specifies:

```bash
pip install torch==2.5.1 torchvision==0.20.1 --index-url https://download.pytorch.org/whl/cu121

```

**Critical limitations apply:** This CUDA 12.1 fallback does not support the batch-renderer component. Use this configuration only if you exclusively need the interactive demo capabilities or base library functions without the Kaolin-dependent rendering pipeline.

## Step-by-Step Installation Guide

Follow these steps to establish a compatible environment according to the repository specifications.

### Create the Python Environment

LingBot-Map requires **Python 3.10 or newer**. Create an isolated environment:

```bash
conda create -n lingbot-map python=3.10 -y
conda activate lingbot-map

```

### Install CUDA-Enabled PyTorch

Execute the official installation command to obtain the CUDA 12.8 wheels:

```bash
pip install torch==2.8.0 torchvision==0.23.0 \
    --index-url https://download.pytorch.org/whl/cu128

```

### Install LingBot-Map

With PyTorch configured, install the library in editable mode:

```bash
pip install -e .

```

### Optional: FlashInfer for Accelerated Attention

For improved attention mechanism performance across CUDA versions, install FlashInfer:

```bash
pip install --index-url https://pypi.org/simple flashinfer-python

```

## Technical Constraints and Dependencies

Understanding the dependency chain explains why specific PyTorch and CUDA versions are mandated.

### NVIDIA Kaolin Dependency

The batch-renderer relies on **NVIDIA Kaolin**, which only distributes pre-compiled wheels for PyTorch 2.8.0 and CUDA 12.8. If you require batch-rendering capabilities, you must use the exact versions specified in the recommended stack.

### Interactive Demo vs. Batch Rendering

The [`demo.py`](https://github.com/Robbyant/lingbot-map/blob/main/demo.py) script can operate with newer PyTorch versions, but activating the full batch-rendering pipeline forces a Kaolin compilation from source if you deviate from the `torch==2.8.0` and `cu128` combination.

### Runtime Verification

The codebase verifies CUDA availability at runtime. In [[`scripts/benchmark_gct_memory.py`](https://github.com/Robbyant/lingbot-map/blob/main/scripts/benchmark_gct_memory.py)](https://github.com/Robbyant/lingbot-map/blob/main/scripts/benchmark_gct_memory.py), the implementation checks for CUDA support using `torch.cuda.is_available()`, confirming the requirement for a CUDA-enabled PyTorch build.

## Summary

- **PyTorch 2.8.0 with CUDA 12.8** is the officially supported environment for full LingBot-Map functionality, including the batch-renderer.
- **PyTorch 2.5.1 with CUDA 12.1** provides a fallback for legacy systems but excludes batch-rendering capabilities due to Kaolin wheel limitations.
- The repository requires **Python 3.10 or newer**.
- File references: [[`README.md`](https://github.com/Robbyant/lingbot-map/blob/main/README.md) line 102](https://github.com/Robbyant/lingbot-map/blob/main/README.md#L102) for primary requirements, [[`benchmark/envs/install_lingbot_map.sh`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh) line 49](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh#L49) for legacy alternatives.

## Frequently Asked Questions

### Can I use LingBot-Map with PyTorch 2.6 or newer versions?

You can run the interactive demo with newer PyTorch versions, but you will lose batch-rendering functionality unless you compile NVIDIA Kaolin from source. The pre-built Kaolin wheels required for batch-rendering only support PyTorch 2.8.0 with CUDA 12.8, so deviating from this combination requires manual compilation of the renderer dependencies.

### Why does LingBot-Map require CUDA 12.8 specifically?

The requirement stems from the batch-renderer's dependency on NVIDIA Kaolin. According to the Robbyant/lingbot-map source code, Kaolin only provides pre-built wheels for the `torch-2.8.0_cu128` combination. While the base library functions may work with older CUDA versions, the rendering pipeline specifically requires the CUDA 12.8 toolkit to leverage these pre-compiled dependencies.

### What happens if I install PyTorch without CUDA support?

The installation will fail at runtime when executing GPU-dependent scripts. The codebase explicitly checks for CUDA availability using `torch.cuda.is_available()` in utilities like [[`scripts/benchmark_gct_memory.py`](https://github.com/Robbyant/lingbot-map/blob/main/scripts/benchmark_gct_memory.py)](https://github.com/Robbyant/lingbot-map/blob/main/scripts/benchmark_gct_memory.py). Without CUDA-enabled PyTorch, you cannot utilize the GPU-accelerated mapping and rendering features that define LingBot-Map's core functionality.

### Is the PyTorch 2.5.1 configuration sufficient for production use?

The PyTorch 2.5.1 with CUDA 12.1 configuration shown in [[`benchmark/envs/install_lingbot_map.sh`](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh)](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh) is suitable for research and development environments where batch-rendering is not required. However, for production deployments utilizing the full rendering pipeline, you must upgrade to PyTorch 2.8.0 with CUDA 12.8 to ensure compatibility with the NVIDIA Kaolin dependency.