Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).
Repository Summary
Checkout URI | https://github.com/ros-tooling/launch_frontend_py.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-10-01 |
Dev Status | DEVELOPED |
Released | UNRELEASED |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
Name | Version |
---|---|
launch_frontend_py | 0.0.0 |
README
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
for
Action andif
attribute 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 launch
from launch_frontend_py.actions import arg, executable
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'),
])
CONTRIBUTING
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that license:
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
Contributors must sign-off each commit by adding a Signed-off-by: ...
line to commit messages to certify that they have the right to submit
the code they are contributing to the project according to the
Developer Certificate of Origin (DCO).