|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.
CONTRIBUTING
|
roboplan_ros repositoryroboplan_ros_cpp roboplan_ros_franka roboplan_ros_py roboplan_ros_visualization |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/open-planning/roboplan-ros.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-25 |
| Dev Status | DEVELOPED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| roboplan_ros_cpp | 0.0.0 |
| roboplan_ros_franka | 0.1.0 |
| roboplan_ros_py | 0.0.0 |
| roboplan_ros_visualization | 0.0.0 |
README
roboplan-ros
ROS 2 wrappers for the roboplan package.
Development Setup
The upstream roboplan package is included as a submodule, be sure to clone it recursively, as it also has submodules.
git clone --recursive https://github.com/open-planning/roboplan-ros
Pixi Development
ROS and the required dependencies are bundled together with pixi and robostack. Different versions of ROS (humble, jazzy, and kilted) are supported with pixi environments. The build relies on the pixi-build-ros backend to manage ROS dependencies from the workspace.
For instance, to build for kilted:
# Setup the environment
pixi run -e kilted setup-colcon
# Build
pixi run -e kilted build
# Run tests, must manually run build prior to executing
pixi run -e kilted test
# Show tests results
pixi run -e kilted test-result
Once the workspace is built, it can be used as a “normal” ROS 2 workspace. That is, the workspace can be sourced and used as expected. However, not that the build/install directories are broken out by ROS distribution, so those arguments MUST be included when compiling.
# Activate the kilted environment
pixi shell -e kilted
# Build with the existing install dirs
colcon build
# Source it
source install/setup.bash
# Or test,
colcon test
The examples from the upstream repository should now be available, as well,
python3 roboplan/roboplan_examples/python/example_scene.py
[!IMPORTANT] All ROS distros will share build/install directories by default. Be sure to clear them out when switching between ROS versions or things will break.
[!NOTE] The
pixi-build-rosbackend requires that allpackage.xmlfiles be reference in the[dev]block of thepixi.tomlfile. This is a slight annoyance due to the submodules, but many of those packages can and will be installed from Conda once RoboPlan is more stable.
Docker Development
A Docker Compose workflow is also provided by the compose specification.
To build and run,
# Build the image, defaults to jazzy but can be overridden by setting $ROS_DISTRO
docker compose build ros
# Start the container
docker compose up ros
# Attach to the running container
docker compose exec ros bash
This will drop the user into a pre-compiled colcon workspace with the source mounted in the image.