|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |
System Dependencies
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged launch_frontend_py at Robotics Stack Exchange
|
launch_frontend_py package from launch_frontend_py repolaunch_frontend_py |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | Apache License 2.0 |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2025-10-22 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Maintainers
- Emerson Knapp
Authors
- Emerson Knapp
Python frontend for ROS 2 Launch
The package launch is the implementation, the “plumbing” of the ROS 2 launch system.
XML and YAML on the other hand are frontends to launch.
That is, they are the intended user-facing API.
However, much of the community got hooked on Python launchfiles due to early adoption when the frontends were incomplete.
With that in mind, and the extensive explicit use of exact filenames and PythonLaunchDescriptionSource, migration to these frontends is difficult for packages with downstream consumers.
Enter launch_frontend_py - this package provides a Python-language frontend to launch, with identical usage to the XML and YAML versions.
It provides the same benefits of conciseness, declarative style, while allowing launchfiles to stay in Python.
Usage
The available actions and substitutions are identical to XML and YAML launchfiles, with one caveat:
[!NOTE] Some launch Actions and their attributes use reserved Python keywords, the known cases are
forAction andifattribute for conditions. For all cases, an underscore_is added at the end:for_,if_.
Here is an example launchfile with a few features:
from launch_frontend_py import arg, executable, launch
def generate_launch_description():
return launch([
arg(name='message', default='hello world'),
arg(name='condition', default='True'),
executable(cmd='echo $(var message)', output='both'),
executable(cmd='echo hello conditional', if_='$(var condition)', output='both'),
executable(cmd='echo hello not-condition', if_='$(not $(var condition))', output='both'),
])
Release Status
| Distro | Dev | Doc | Src | Ubuntu x64 |
|---|---|---|---|---|
| Rolling | ||||
| Kilted | ||||
| Jazzy | ||||
| Humble |
Changelog for package launch_frontend_py
0.1.0 (2025-10-05)
- Repository created with README and LICENSE
- CI via github actions
- Initial implementation of package functionality, these PRs making
incremental progress
- Launch description initial (#2)
- Try more action types, clean up exporting, add basic test (#3)
- Handle creating exposed actions as needed regardless of import order (#4)
- Handle positional list arg as [children]{.title-ref} (#7)
- Rename from launch_py to launch_frontend_py (#9)
- Add tests for running actual launchfile (#11)
- Enable Python reserved names in Action attributes (#12)
- Add basic usage to readme (#15)
- Let all imports come from toplevel module, as one line (#16)
- Contributors: Emerson Knapp
Package Dependencies
| Deps | Name |
|---|---|
| ament_cmake | |
| ament_cmake_python | |
| ament_copyright | |
| ament_lint_auto | |
| ament_lint_common | |
| ament_cmake_mypy | |
| ament_cmake_pytest | |
| launch |