|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged bob_launch at Robotics Stack Exchange
|
bob_launch package from bob_launch repobob_launch |
ROS Distro
|
Package Summary
| Version | 1.0.1 |
| License | Apache-2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/bob-ros2/bob_launch.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-28 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Bob Ros
Authors
- Bob Ros
ROS Package bob_launch
bob_launch is a powerful meta-launcher for ROS 2 that enables dynamic system orchestration using YAML or JSON configuration files. It allows you to define, compose, and launch complex ROS 2 graphs without writing boilerplate Python launch files.
High-Level Capabilities
- Dynamic Orchestration: Spawn nodes or include other launch files based on external configuration.
- Composition over Coding: Define your entire ROS system in simple YAML.
-
Streamlined Workflow: Use the
launch.shwrapper or native ROS 2 launch arguments. - Auto-Abort Protection: Optionally shut down the entire launch tree if any critical node exits (ideal for Docker/CI).
- Global Parameters: Inject a shared parameter file into all nodes launched within a configuration.
-
Path Placeholders: Use
//PKGSHARE/(current node package) or//PKGSHARE:pkg/to dynamically resolve ROS 2 package share directories in parameters and arguments. -
Environment Substitution: Support for shell-like
${VAR}or${VAR:-default}syntax in all configuration fields and relevant launch arguments.
Native ROS 2 Usage (Preferred)
You can call the launch file directly using standard ROS 2 launch arguments:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml
To pass an optional global node parameter file:
ros2 launch bob_launch generic.launch.py config:=my_config.yaml config_nodes:=node_params.yaml
Note: You can also use the environment variable BOB_LAUNCH_CONFIG=./my_config.yaml as an alternative to the config:= argument.
Fast Execution: launch.sh
The launch.sh script is a convenient wrapper that simplifies execution by handling environment variables and temporary file management for you.
1. Launch from a file
ros2 run bob_launch launch.sh my_config.yaml
2. Launch with a global parameter file
ros2 run bob_launch launch.sh my_config.yaml global_params.yaml
3. Launch from a JSON config file
ros2 run bob_launch launch.sh my_config.json
Advanced Usage
bob_launch is designed to be highly scriptable, making it an ideal tool for AI Agents needing to spawn ROS components on the fly.
Pipe a String Directly (Dynamic Spawning)
An agent can generate a YAML string and pipe it directly to the launcher without creating a persistent file:
echo "- name: talker
package: demo_nodes_cpp
executable: talker" | ros2 run bob_launch launch.sh
Multi-File Composition
You can quickly composite different system “layers” (e.g., base drivers + perception + mission logic) by concatenating files into the pipe:
cat base_robot.yaml nav2_stack.yaml custom_logic.yaml | ros2 run bob_launch launch.sh
Dynamic Substitution & Placeholders
bob_launch supports powerful dynamic string substitution in all configuration fields and launcher arguments (like config:= and config_nodes:=).
Environment Variables (${VAR})
Supports shell-like syntax for dynamic values:
-
${MYVAR}: Replaces with the value or an empty string. -
${MYVAR:-/default/path/}: Replaces with the value or the specified default if unset.
Path Placeholders (//PKGSHARE)
Avoid hardcoded absolute paths by dynamically resolving ROS 2 package share directories:
-
//PKGSHARE/: Resolves to the share directory of the package defined for the current entity (implicit). -
//PKGSHARE:pkg_name/: Resolves to the share directory ofpkg_name(explicit).
Combination & CLI Usage
These mechanisms can be combined and even used directly in the ros2 launch command arguments:
ros2 launch bob_launch generic.launch.py \
config:='//PKGSHARE:my_pkg/config/${ROBOT_ENV:-dev}.yaml'
To disable environment substitution, set BOB_SUBSTITUTE_ENV_VARS=0.
Configuration Schema
Spawning Nodes
```yaml
- name: usb_cam # Optional: defaults to executable_name + random suffix
package: usb_cam
executable: usb_cam_node_exe
arguments: # Optional: list of CLI arguments
- –ros-args
File truncated at 100 lines see the full file
Changelog for package bob_launch
1.0.1 (2026-02-03)
- Fix linter and style issues for ROS2 compliance
- Standardize docstrings and copyright headers
- Refactor launch parameter
- Add support for 'prefix' parameter in configuration
- Add support for inline 'parameters' in node configuration
- Add support for '//PKGSHARE' and '//PKGSHARE:pkg' placeholders for dynamic path resolution
- Add support for environment variable substitution (${VAR} and ${VAR:-default}) in configuration files
- Enable dynamic placeholder resolution for 'config' and 'config_nodes' launch arguments
- Standardize placeholder resolution across all configuration fields including 'launch_ns'
- Add support for native ROS 2 remappings in node configurations
- Add support for [respawn_delay]{.title-ref} in node configurations
- Contributors: Bob Ros
1.0.0 (2026-02-02)
- Initial release
- Contributors: Bob Ros
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_lint_auto | |
| ament_lint_common |