# Cupoch moves point cloud pipelines from the CPU onto the GPU

> Cupoch is a C++ and Python library that implements the 3D data processing stack a robot needs, from ICP registration and distance transforms to occupancy grids and collision checking, with the heavy steps written in CUDA. It is packaged for 64-bit Ubuntu with CUDA 12.9, and the last push was on 2026-06-25 while the newest tagged release is still v0.2.11.0.

**neka-nat/cupoch** — Robotics with GPU computing

- Repository: https://github.com/neka-nat/cupoch
- Stars: 1,065 · Forks: 123
- Language: C++
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/neka-nat-cupoch

## The whole robot perception stack, not one algorithm

Cupoch describes itself as a library that implements rapid 3D data processing for robotics using CUDA, with the stated goal of fast 3D data computation in robot systems and applications in SLAM, collision avoidance, path planning and tracking. The breadth is the point. The feature list covers nearest neighbour queries, point cloud registration with ICP, generalized ICP, symmetric ICP, colored point cloud registration, Fast Global Registration and FilterReg, point cloud features including FPFH and SHOT, ISS keypoints, density based clustering, filtering and down sampling, file and ROS message IO, creating point clouds from laser scans or RGBD images, visual odometry, Kinect Fusion, stereo matching, collision checking, occupancy grids, distance transforms, graph path finding and path planning for collision avoidance. That is a stack, not a utility, and the breadth is also the maintenance surface.

## CUDA everywhere, with memory pools and managed allocators underneath

Two lower level features sit alongside the algorithms, and they are what make a large GPU port practical. The first is support for a memory pool and managed allocators, which matters because the algorithms repeatedly allocate and free large device buffers for point clouds, and a naive allocator on a GPU is a common source of stalls. The second is the interaction with the host: the library ships an interactive GUI built on OpenGL and CUDA interop with imgui, so a developer can look at a cloud interactively rather than only through a script. There is also interoperability with DLPack data structures, which the README names as covering PyTorch and CuPy arrays, so a tensor produced elsewhere can cross into cupoch without a manual copy.

## Registration and distance transform, with papers behind each entry

The feature list cites sources for most algorithms, which tells you these are ported research results rather than approximations. Registration includes ICP, generalized ICP, symmetric ICP, colored point cloud registration, Fast Global Registration and FilterReg, several with a linked paper. Features include FPFH and SHOT, keypoints include ISS, and clustering points at a GPU implementation of G-DBSCAN. The distance transform entry links the parallel banding algorithm for computing an exact distance transform on the GPU. Visual odometry is likewise anchored to two published RGB-D odometry approaches. The practical reading is that the library is a curated set of known algorithms, ported to a GPU backend, with a consistent interface.

## Installing the pip wheel or building it yourself

The library is packaged for 64-bit Ubuntu Linux 24.04 with CUDA 12.9, and the quick path is a single pip command.

```bash
pip install cupoch
```

Building from source is a CMake run that produces a pip package, and the clone is done with submodules included.

```bash
git clone https://github.com/neka-nat/cupoch.git --recurse
cd cupoch
mkdir build
cd build
cmake ..; make install-pip-package -j
```

There is a Docker path as well, using a compose file that requests GPU devices and mounts the X11 socket so the interactive GUI can draw.

```sh
docker compose up -d
# xhost +
docker exec -it cupoch bash
```

The repository's Dockerfile shows what a container build looks like: it starts from a CUDA devel image, installs cmake and the X11 development headers, uses poetry for the Python module, and turns on the GLEW, GLFW, PNG and JSONCPP options at configure time. The same GPU device request appears in the compose file, along with privileged mode.

## The AMD path exists, and two features do not make the trip

Cupoch also builds on AMD GPUs through ROCm by turning on a CMake option, and the same set of modules is produced as in the CUDA build, covering the GPU compute modules, the OpenGL visualization and the Python module. The GPU architecture is detected automatically, with a CMake variable to override it for cross compiling. The CUDA build is unchanged, since the option defaults to off. Two features are missing on the AMD path. The libSGM based stereo matcher in the image processing module is not available, and ScalableTSDFVolume is not available because its device hash map stores a volume unit too large for the AMD GPU scratch limit, with UniformTSDFVolume named as the substitute. Both are skipped automatically and the rest of the library is unaffected, which is a more honest arrangement than a build that fails late.

## Jetson needs its own branch and its own dependency list

For Jetson Nano the README gives a separate path, and the branch name differs from the default. A pip install works on Jetson Nano once the device is set up with Jetpack and some apt packages are installed.

```bash
sudo apt-get install xorg-dev libxinerama-dev libxcursor-dev libglu1-mesa-dev
pip3 install cupoch
```

The source route for that platform clones a specific branch, sets the CUDA path in the environment and turns on the same four build options as the container build.

```bash
git clone -b jetson_nano https://github.com/neka-nat/cupoch.git --recurse
cd cupoch/
mkdir build
cd build/
export PATH=/usr/local/cuda/bin:$PATH
cmake -DBUILD_GLEW=ON -DBUILD_GLFW=ON -DBUILD_PNG=ON -DBUILD_JSONCPP=ON ..
sudo make install-pip-package
```

The branch and the extra packages are the signal here. Embedded targets are a separate build configuration, not an accident of the main one.

## Speed claims come with the machine they were measured on

The results section reports a figure comparing point cloud algorithm speed against Open3D, and it lists the test environment rather than leaving it implicit: an Intel Core i7-7700HQ CPU, an Nvidia GTX1070 GPU and OMP_NUM_THREAD set to 1. The README says you can reproduce it by running the example script in your own environment.

```sh
cd examples/python/basic
python benchmarks.py
```

Two cautions belong with that figure. The comparison target is Open3D, and the cupoch repository is itself based on Open3D, so the interesting result is a speedup of a port over the code it was ported from. And the hardware is a laptop-class CPU with a 2016 generation GPU, so a reader should not read the numbers as a claim about current hardware. The examples directory also includes a C++ tree and a testdata directory, so the same algorithms are reachable from both language bindings.

## Maintenance state: recent commits, older release tags

The repository is not archived, and the last push was on 2026-06-25. The release tags tell a slower story. The newest is v0.2.11.0 from 2024-06-08, with v0.2.10.0 from 2023-12-09 and v0.2.9.0 from 2023-11-29 before it. The version numbers themselves are still in the zero series, so the library has not been marked stable by its own numbering. The README also points to a Getting Started document for first use, and to a documentation directory that a mkdocs configuration serves. Licence is MIT, and the tree includes a LICENSE file at the root, a CMakeLists.txt at the root, a cmake directory, a src directory, a third_party directory and a scripts directory. One more detail deserves a mention because it is a genuine gap rather than a version number: the KNN entry in the feature list is marked as work in progress, with a link to a paper on optimizing LBVH construction and hierarchy traversal.

## Conclusion

Cupoch fits a robotics team that already runs on NVIDIA hardware and needs point cloud registration, occupancy grids or collision checking to keep up with sensor rate on a CPU-limited embedded board. It does not fit a project that has to build today, because the last push was on 2026-06-25 and the newest release tag is v0.2.11.0 from 2024-06-08, and it does not fit an AMD build that needs the libSGM stereo matcher or ScalableTSDFVolume, both of which are skipped on the ROCm path. Before you adopt it, check that the pip wheel matches your CUDA version, and read the KNN entry, which is still marked as work in progress.

## FAQ

### How do I install cupoch?

The packaged path is `pip install cupoch`, and the library is packaged for 64-bit Ubuntu Linux 24.04 with CUDA 12.9. Building from source means cloning with `--recurse` and running `cmake ..; make install-pip-package -j` in a build directory.

### Can cupoch run on AMD GPUs?

Yes, with a CMake configure using `-DUSE_HIP=ON` and a release build type, which produces the same modules as the CUDA build. The GPU architecture is detected automatically and can be overridden with `-DCMAKE_HIP_ARCHITECTURES`.

### Which cupoch features are missing on the ROCm build?

Two. The libSGM based stereo matcher in the image processing module, and ScalableTSDFVolume, whose device hash map stores a volume unit too large for the AMD GPU scratch limit, with UniformTSDFVolume offered instead. Both are skipped automatically.

### What point cloud algorithms does cupoch implement?

The feature list covers ICP, generalized ICP, symmetric ICP, colored point cloud registration, Fast Global Registration and FilterReg for registration, FPFH and SHOT for features, ISS for keypoints, a GPU implementation of G-DBSCAN for clustering, plus visual odometry, stereo matching, occupancy grids, distance transforms and path planning.

### How do I install cupoch on Jetson Nano?

The README describes a pip install on Jetson Nano after setting up the device with Jetpack and installing `xorg-dev`, `libxinerama-dev`, `libxcursor-dev` and `libglu1-mesa-dev`. The source route clones the `jetson_nano` branch and configures with the GLEW, GLFW, PNG and JSONCPP options turned on.

### How do I run the cupoch benchmarks?

The README points at the example script in the examples directory, run as `python benchmarks.py` from `examples/python/basic`. The reference environment listed for the comparison is an Intel Core i7-7700HQ CPU with an Nvidia GTX1070 GPU and OMP_NUM_THREAD set to 1.

## Sources

- [Issues](https://github.com/neka-nat/cupoch/issues)
- [License: MIT](https://github.com/neka-nat/cupoch/blob/main/LICENSE)
- [neka-nat/cupoch on GitHub](https://github.com/neka-nat/cupoch)
- [README](https://github.com/neka-nat/cupoch/blob/main/README.md)
- [Releases](https://github.com/neka-nat/cupoch/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/neka-nat-cupoch