KavrakiLab

vamp: SIMD-Accelerated Sampling-Based Motion Planning

VAMP is a C++ motion-planning library that uses CPU SIMD instructions to speed up robot kinematics and collision checking. It supports x86 AVX2 and ARM NEON, with Python bindings and planners including RRT-Connect, PRM, FCIT*, and AORRTC.

ActiveC++Apache-2.0LibraryPerformanceRobotics
View on GitHub Compare
Stars
495
Forks
93
Stars, last 30 days
+15
Last commit
22 days ago
Contributors
15

Our take

Activerecent releases

Health score

41/100

How it is scored
Activity
45
Community
53
Issues
21
Pull requests
46

+15 stars in the last 30 days

VAMP is a specialized, actively maintained planning library with recent releases and a contributor base that is not concentrated around one person, but it requires comfort with robot geometry and architecture-specific builds.

Good fit if

  • You need sampling-based planning for supported robots and can use AVX2 or NEON hardware.
  • Your workflow benefits from Python bindings, C++ extension points, or point-cloud collision checking with CAPT.
  • You want an Apache-2.0-licensed library with recent releases and ongoing contributions.

Look elsewhere if

  • You need manifold-constrained planning or time-optimal trajectory parameterization, which the README lists as planned work.
  • You need an out-of-the-box model for a robot not included with VAMP and cannot generate custom robot code and collision geometry.
  • Your target CPU does not support the documented AVX2 or NEON platforms.
All health signals
Last commit2026-09-28 (22 days ago)
Commits, last 90 days2
Releases, last 12 months3 (latest v0.6.4, 2026-05-11)
Contributors15 (top contributor: 55% of commits)
Issues closed, last 90 days0
Pull requests merged, last 90 days2
Project age2 years

Checked on 2026-10-21 with the GitHub API.

Project history

Daily GitHub snapshots since Oct 7, 2026. History covers stars and forks; health signals are not tracked historically.

Selected snapshot

Stars

509

Forks

100

Change since Nov 17, 2026: +1 stars·+1 forks

Overview

VAMP is a C++ library for sampling-based robot motion planning, built around CPU SIMD instructions to accelerate forward kinematics and collision checking. It targets x86 CPUs with AVX2 and ARM CPUs with NEON, aiming to make planning practical in tight runtime budgets without requiring a GPU. Python bindings provide access to the planning and robot functions.

The library includes models for several robot arms and a flying sphere, plus planners ranging from RRT-Connect and PRM to asymptotically optimal FCIT* and AORRTC. Its point-cloud collision checking uses the Collision-Affording Point Tree (CAPT). VAMP suits robotics developers who need fast planning and collision checks, especially when their robot and environment can be represented with its supported models and geometry.

Key Features

  • SIMD-accelerated forward kinematics and collision checking, with AVX2 and NEON implementations.
  • RRT-Connect, PRM, FCIT*, and AORRTC planners, with support for multiple goal configurations.
  • CAPT spatial structures for point-cloud collision checking.
  • Python bindings and a C++ interface, with precompiled support for the UR5, Panda, Fetch, and Baxter robots.
  • Collision environments with primitive shapes, heightfields, point clouds, and convex polytopes.
  • Path simplification routines including shortcutting, B-spline smoothing, and randomized perturbation.
  • WebAssembly builds for browser use, using 128-bit SIMD.

Use Cases

  • Robotics researchers benchmarking sampling-based planners on MotionBenchMaker problems.
  • Robotics developers seeking fast collision checking and planning for supported robot models on CPU hardware.
  • Teams planning around point-cloud scenes that can use CAPT for collision queries.
  • Developers prototyping planning workflows in Python before extending or integrating the C++ core.

What you need

Detected in the repository

  • Python >=3.8 (from pyproject.toml)
  • A test suite and automated checks on GitHub Actions

License in plain words

Apache-2.0permissive

  • Commercial use: yes
  • Modify and redistribute: yes
  • You must keep: the license, the NOTICE file and a note of your changes
  • Share your changes: no
  • Includes an explicit patent grant from the contributors:

A summary, not legal advice: the LICENSE file is what applies.

Getting Started

Install the Python package from PyPI:

pip install vamp-planner

For source builds, C++ development, and examples, see the README.

Considerations

VAMP is active, with recent releases and commits; its contributors are not concentrated around a single person. The supplied health data shows no issues closed in the recent measurement period, so do not assume prompt issue resolution. Building from source requires CMake, a supported C++ compiler, Python development headers, and Eigen 3.4 or newer. Performance depends on supported CPU SIMD instructions, and custom robots require generated code and a spherical collision-geometry approximation. The README also identifies improved API documentation and manifold-constrained planning as unfinished areas.

Found this useful?

Share it with someone who would like vamp.