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

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 line 102](https://github.com/Robbyant/lingbot-map/blob/main/README.md#L102).

This combination uses the cu128 wheel index:

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 line 49](https://github.com/Robbyant/lingbot-map/blob/main/benchmark/envs/install_lingbot_map.sh#L49) specifies:

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:

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:

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:

pip install -e .

Optional: FlashInfer for Accelerated Attention

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

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 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), 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 line 102](https://github.com/Robbyant/lingbot-map/blob/main/README.md#L102) for primary requirements, [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). 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) 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}