Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
jazzy

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
kilted

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
rolling

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro iron showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange

No version for distro noetic showing humble. Known supported distros are highlighted in the buttons above.
Package symbol

launch_frontend_py package from launch_frontend_py repo

launch_frontend_py

ROS Distro
humble

Package Summary

Version 0.0.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-01
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Python frontend for writing ROS 2 launch files

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 for Action and if 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'),
    ])

CHANGELOG
No CHANGELOG found.

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged launch_frontend_py at Robotics Stack Exchange