     * /camera2/realsense2_camera/fisheye_height: 480
     * /camera2/realsense2_camera/fisheye_optical_frame_id: camera_fisheye_op...
     * [ INFO] [1527577076.615978423]: Initializing nodelet with 4 worker threads.
    [ INFO] [1527577076.672905307]: RealSense ROS v2.0.3
    [ INFO] [1527577076.672932398]: Running with LibRealSense v2.11.0
     29/05 12:27:56,679 DEBUG [139779508533120] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
     29/05 12:27:56,679 DEBUG [139779508533120] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
    [DEBUG] [1527577076.930240765]: Device with serial number 805212060530 was found.
     29/05 12:27:57,033 INFO [139779508533120] (environment.cpp:85) Found 4 unreachable streams, 4 extrinsics deleted
    [ INFO] [1527577076.623277590]: Initializing nodelet with 4 worker threads.
    [ INFO] [1527577076.681532837]: RealSense ROS v2.0.3
    [ INFO] [1527577076.681553113]: Running with LibRealSense v2.11.0
     29/05 12:27:57,034 DEBUG [140517600331648] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
     29/05 12:27:57,034 DEBUG [140517600331648] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
    [DEBUG] [1527577077.038725101]: Device with serial number 805212060147 was found.
    [ INFO] [1527577077.038850887]: Resetting device...
     29/05 12:27:57,135 INFO [139778838230784] (types.h:926) Current firmware version: 05.08.15.00
    Latest firmware release: 05.09.09.02

    [DEBUG] [1527577077.043918005]: Device with serial number 805212060530 was found.
    [ INFO] [1527577077.044000407]: Resetting device...
     29/05 12:27:57,141 INFO [140516918580992] (types.h:926) Current firmware version: 05.08.15.00
    Latest firmware release: 05.09.09.02

     29/05 12:28:01,679 DEBUG [139778917799680] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
     29/05 12:28:01,679 DEBUG [139778917799680] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
     29/05 12:28:01,679 DEBUG [139778917799680] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
     29/05 12:28:01,679 DEBUG [139778917799680] (ds5-factory.cpp:279) try_fetch_usb_device(...) failed.
     29/05 12:28:01,679 DEBUG [139778917799680] (context.cpp:366)
    Device disconnected:

    uvc devices:
    id- /dev/video5
    vid- 8086
    pid- ad3
    mi- 3
    unique_id- 2-2-22
    path- /sys/devices/pci0000:00/0000:00:14.0/usb2/2-2/2-2:1.3/video4linux/video5
    susb specification- 310


    /diagnostics
    /diagnostics
    /diagnostics
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/metadata
    /camera/depth/camera_info
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/realsense2_camera_manager/bond
    /camera/realsense2_camera_manager/bond
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/camera_info
    /camera/depth/metadata
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/metadata
    /camera/depth/camera_info
    /camera/depth/image_rect_raw
    /rosout_agg
    /diagnostics
    /diagnostics
    /diagnostics
    /diagnostics
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/metadata
    /camera/depth/camera_info
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/realsense2_camera_manager/bond
    /camera/realsense2_camera_manager/bond
    /camera/depth/image_rect_raw/compressedDepth


553  // Let's decide upon an output format


Image data for use with OpenCV.


230  static  const  std::map<std::pair<Encoding, Encoding>, std::vector<int> >
CONVERSION_CODES = getConversionCodes();


[ cv_bridge::CvImage::CvImage
](classcv__bridge_1_1CvImage.html#adcb3774384cd81c101f3c9beedede4e7)


CvImage()


[ ](//www.rssing.com/index.php?zw=2123 "Home") [ $ ](javascript:; "MoMoney")


###  [ Calgary Hells Angels implicated in another fraud
](////hullabaloo16.rssing.com/chan-9145637/article818.html#c9145637a818i695428444)


    /camera/aligned_depth_to_color/camera_info
    /camera/aligned_depth_to_color/image_raw/compressedDepth
    /camera/aligned_depth_to_color/image_raw/compressed
    /rosout
    /camera/color/camera_info
    /camera/aligned_depth_to_color/image_raw
    /rosout
    /rosout_agg
    /rosout_agg
    /camera/color/image_raw/compressed
    /camera/color/image_raw
    /camera/depth/camera_info
    /camera/color/image_raw/theora
    /camera/color/metadata
    /rosout
    /camera/depth/metadata
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/aligned_depth_to_color/camera_info
    /camera/aligned_depth_to_color/image_raw/compressedDepth
    /camera/aligned_depth_to_color/image_raw/compressed
    /rosout
    /camera/color/camera_info
    /rosout
    /camera/aligned_depth_to_color/image_raw
    /rosout_agg
    /rosout_agg
    /camera/color/image_raw/compressed
    /camera/color/image_raw
    /camera/color/image_raw/theora
    /camera/depth/camera_info
    /camera/color/metadata
    /camera/depth/image_rect_raw
    /rosout
    /camera/depth/camera_info
    /camera/depth/metadata
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/depth/camera_info
    /rosout


350  return  ptr;


[ ](javascript:; "Like") 0


[ _≪_ Previous: depth_image_proc point_cloud_xyzrgb
](//question2135.rssing.com/chan-36145539/all_p3.html#c36145539a60 "Previous
Article")


int colormap


Clear


Copy link


    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/camera_info
    /camera/depth/metadata
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/realsense2_camera_manager/bond
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/camera_info
    /camera/depth/metadata
    /camera/depth/image_rect_raw
    /rosout_agg
    /diagnostics
    /diagnostics
    /diagnostics
    /diagnostics
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/camera_info
    /camera/depth/metadata
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/realsense2_camera_manager/bond
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/metadata
    /camera/depth/camera_info
    /camera/depth/image_rect_raw
    /rosout_agg
    /camera/realsense2_camera_manager/bond
    /camera/depth/image_rect_raw/compressedDepth
    /camera/depth/image_rect_raw/compressed
    /rosout
    /camera/depth/camera_info
    /camera/depth/metadata


341  // Perform color conversion


Empty constructor.


309  // Copy to new buffer if same encoding requested


255  if  (source.step < source.width * byte_depth * num_channels)


[ _≪_ Previous: why RGB and depth Image synchronization not working?
](//question2135.rssing.com/chan-36145539/all_p4.html#c36145539a62 "Previous
Article")


Sign up for GitHub


{{ message }}


RSSing.com


464  return  "pgm"  ;


384  memcpy(ros_data_ptr, cv_data_ptr, ros_image.step);


This works well thanks, giving an Aligned and Ordered PointCloud. (i.e. from
"roslaunch realsense2_camera rs_camera.launch align_depth:=true
filters:=pointcloud ordered_pc:=true")


  * [ File List  ](files.html)
  * [ File Members  ](globals.html)


Skip to content


When I run the script I get this output:


275  byte_depth == 1)


[ cv_bridge::JPEG
](namespacecv__bridge.html#a166887feb09ea6ce14e8742384e574bfadc1cd099bb82f23f7b591f52411da82f)


74  // Check for the most common encodings first


Showing article 61 to 80 of 122 in channel 36145539
Channel Details:


July 20, 2016, 9:38 am


609  }


586  }


472  return  "tif"  ;


Sorry, something went wrong.


  * [ RSSing>> ](//www.rssing.com/index.php)
    * Collections:
    * [ RSSing ](//www.rssing.com/index.php)
    * [ EDA ](//www.rssing.com/d/eda/index.php)
    * [ Intel ](//www.rssing.com/d/intel/index.php)
    * [ Mesothelioma ](//www.rssing.com/d/mesothelioma/index.php)
    * [ SAP ](//www.rssing.com/d/sap/index.php)
    * [ SEO ](//www.rssing.com/d/seo/index.php)
  * [ Latest  ](//www.rssing.com/index.php?l=l)
    * [ Articles ](//www.rssing.com/index.php?l=la)
    * [ Channels ](//www.rssing.com/index.php?l=lc)
    * [ Super Channels ](//www.rssing.com/index.php?l=ls)
  * [ Popular  ](//www.rssing.com/index.php?l=p)
    * [ Articles ](//www.rssing.com/index.php?l=pa)
    * [ Pages ](//www.rssing.com/index.php?l=pp)
    * [ Channels ](//www.rssing.com/index.php?l=pc)
    * [ Super Channels ](//www.rssing.com/index.php?l=ps)
  * [ Top Rated  ](//www.rssing.com/index.php?l=r)
    * [ Articles ](//www.rssing.com/index.php?l=ra)
    * [ Pages ](//www.rssing.com/index.php?l=rp)
    * [ Channels ](//www.rssing.com/index.php?l=rc)
    * [ Super Channels ](//www.rssing.com/index.php?l=rs)
  * [ Trending  ](//www.rssing.com/index.php?l=t)
    * [ Articles ](//www.rssing.com/index.php?l=ta)
    * [ Pages ](//www.rssing.com/index.php?l=tp)
    * [ Channels ](//www.rssing.com/index.php?l=tc)
    * [ Super Channels ](//www.rssing.com/index.php?l=ts)


200  {


[ ![First Pictures of the Eclipse ! !
!](//thepeoplescube.com/red/download/file.php?id=57243&sid=5311a0068099bb708e6eae6fd0456e59)
](////political6691.rssing.com/chan-78391714/article69.html#c78391714a69i1437484910)


697  }


86  // For bayer, return one-channel


[ ](javascript:; "Ouch") 0


475  }


675  else  if  (source->encoding ==  "CV_8UC3"  )


[ ](//www.rssing.com/index.php?zw=2123 "Home") [ $ ](javascript:; "MoMoney")


[ cv_bridge ](http://wiki.ros.org/cv_bridge)
Author(s): Patrick Mihelich, James Bowman  autogenerated on Thu Jun 6 2019
19:57:55


671  if  (source->encoding ==  "CV_8UC1"  )


[ cv_bridge::rgb_colors::getRGBColor
](namespacecv__bridge_1_1rgb__colors.html#ae0042fb7032cf0b5a4770f7d16c6cc90)


July 1, 2016, 2:36 pm


double min_image_value


[ Search ](javascript:;)


307  ptr->header = src_header;


647  (max_image_value - min_image_value));


667  source_typed->header = source->header;


[ ](javascript:; "Like") 0


677  else  if  (source->encoding ==  "CV_8UC4"  )


615  {


36  #include "boost/endian/conversion.hpp"


90  if  (encoding == enc::BAYER_GRBG8)  return  CV_8UC1;


[ Browse latest ](//question2135.rssing.com/chan-36145539/index-latest.php) [
View live ](//question2135.rssing.com/chan-36145539/article61-live.html)


[ ![@CWAndersn](https://avatars.githubusercontent.com/u/36552123?s=80&v=4)
](/CWAndersn)


Collaborator


Sorry, something went wrong.


[ ![Visualizing Point Clouds with Custom Colors](/images/blog/visualizing-
point-clouds-with-custom-colors/hero.webp) ](/blog/visualizing-point-clouds-
with-custom-colors)


NOTE: by convention, the roslaunch XML files are named with the extension `
.launch ` , e.g. ` example.launch ` .


Compile your workspace with ` catkin_make ` and source your workspace before
you run your launch file:


Follow


#  Wiki


####  ` <unset_env> ` Tag


* [ <test> ](/roslaunch/XML/test)


  1. Evaluation order
  2. substitution args
  3. if and unless attributes
    1. Example
  4. Tag Reference
  5. Example .launch XML Config Files
    1. Minimal Example
    2. A More Complicated Example
    3. Setting parameters


    $ roslaunch launch_pkg launch_example.launch.py
      ... logging to /home/jose/.ros/log/6ceb21b0-56e5-11ed-8d02-ede36847100a/roslaunch-jose-hp-10609.log
      Checking log directory for disk usage. This may take a while.
      Press Ctrl-C to interrupt
      Done checking log file disk usage. Usage is <1GB.

      started roslaunch server http://jose-hp:42669/

      SUMMARY
      ========

      PARAMETERS
      * /rosdistro: noetic
      * /rosversion: 1.15.14

      NODES
        /
        compute_node (launch_pkg/compute_node)
        motor_node (launch_pkg/motor_node)
        sensor_node (launch_pkg/sensor_node)

      auto-starting new master
      process[master]: started with pid [10625]
      ROS_MASTER_URI=http://localhost:11311

      setting /run_id to 6ceb21b0-56e5-11ed-8d02-ede36847100a
      process[rosout-1]: started with pid [10642]
      started core service [/rosout]
      process[sensor_node-2]: started with pid [10645]
      process[compute_node-3]: started with pid [10646]
      process[motor_node-4]: started with pid [10651]
      [ INFO] [1666977890.709897549]: Read value 17767
      [ INFO] [1666977890.712234400]: Received value 17767, sending 1.00
      [ INFO] [1666977890.715850085]: Received value 1.00
      [ INFO] [1666977890.717371423]: Moving motors forward
      [ INFO] [1666977891.709779304]: Read value 9158
      [ INFO] [1666977891.710294371]: Received value 9158, sending 1.00
      [ INFO] [1666977891.710665976]: Received value 1.00


              <xs:documentation xml:lang="en">
                A collection of ROS parameters, ROS remappings and/or
                environment variable settings for the launched ROS node.
              </xs:documentation>
            </xs:annotation>
            <xs:element ref="env"/>
            <xs:element ref="param"/>
            <xs:element ref="remap"/>
          </xs:choice>
          <xs:attribute name="pkg" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name of the package where the node is to be found.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="exec" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name of the node executable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="name" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A name for the launched ROS node.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="ros_args" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                ROS-specific 'command-line' arguments for the ROS node.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="args" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">


The body of such a description is mainly comprised of statically declared
launch actions with a prescribed configuration. To that, runtime value
substitution is added in order to fullfill common dynamic (re)configuration
needs like conditional execution, resource lookups, etc. It is intended for
these entities to map to those of the underlying implementation, reducing
support to file parsing.


` $(optenv ENVIRONMENT_VARIABLE) ` ` $(optenv ENVIRONMENT_VARIABLE
default_value) `


     Substituted by the value of the given environment variable Substitution will fail if the variable is not set, unless a default value is provided.
` $(eval <python-expression>) `


     Substituted by the share directory path of the given package. The share directory includes the package’s name, e.g. ` <prefix>/share/<pkg-name> ` . Forward and backwards slashes will be resolved to the local filesystem convention. Substitution will fail if the package cannot be found.
` $(find-exec <exec-name>) `


[ How to Use ROS 2 Launch Files  ](/blog/how-to-use-ros2-launch-files)


* [ <env> ](/roslaunch/XML/env)


Published  October 31, 2022


        </xs:annotation>

        <xs:complexType>
          <xs:sequence minOccurs="0" maxOccurs="unbounded">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Arguments for the included launch file, if any.
              </xs:documentation>
            </xs:annotation>

            <xs:element name="arg">
              <xs:annotation>
                <xs:documentation xml:lang="en">
                  An included launch file argument provision.
                </xs:documentation>
              </xs:annotation>

              <xs:complexType>
                <xs:attribute name="name" type="xs:string" use="required">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">
                      Name of the launch argument.
                    </xs:documentation>
                  </xs:annotation>
                </xs:attribute>
                <xs:attribute name="value" type="xs:string" use="required">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">
                      Value for the launch argument.
                    </xs:documentation>
                  </xs:annotation>
                </xs:attribute>
              </xs:complexType>
            </xs:element>
          </xs:sequence>
          <xs:attribute name="file" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Path to the launch file to be included.
              </xs:documentation>


[ ros2 run - symbol not found on custom msg ](/question/326008/ros2-run-
symbol-not-found-on-custom-msg/)


####  User-defined Substitutions


![How to Use ROS 1 Launch Files](/images/blog/how-to-use-ros1-launch-
files/hero.webp)


[ Shiva_uchiha ](/users/37455/shiva_uchiha/)
117  ●  18  ●  22  ●  25


[ rosbag2 doesn't write meta data file ](/question/397687/rosbag2-doesnt-
write-meta-data-file/)


* Using the Launch files from the command line


#####  Description


Now that we’ve created launch files that execute multiple nodes, let’s include
Foxglove Studio in the development process.


[ ![Joe28965 gravatar
image](/upfiles/avatars/Joe28965/resized/16/48763690.png)
](/users/50769/joe28965/) [ Joe28965 ](/users/50769/joe28965/) (  2021-06-11
03:28:32 -0500  )  edit


####  ` <arg> ` Tag


edit


The ` <group> ` tag allows for launch actions’ grouping as well as optional
launch file configuration scoping.


    <group>
      <unset_env name="MY_ENV_VAR"/>
    </group>


This article describes XML aiming to ease the bridge between ROS and ROS 2
launch files. YAML is currently supported too, and other markup languages
could be added.


###  Controlling the turtles  ï


##  Using Foxglove Studio


[ gvdhoorn ](/users/5184/gvdhoorn/)
86574  ●  283  ●  1432  ●  1054  [ http://cor.tudelft.nl/
](http://cor.tudelft.nl/ "gvdhoorn's website is http://cor.tudelft.nl/")


    <?xml version="1.0"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
      xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning"
      vc:minVersion="1.1">
      <xs:annotation>
        <xs:documentation xml:lang="en">
          ROS 2 launch XML schema v0.1.0
        </xs:documentation>
      </xs:annotation>

      <xs:element name="launch">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            The root element of a launch file.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:choice maxOccurs="unbounded">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A collection of actions to be launched in order of appearance, plus
                launch arguments for callers to provide, either through a tool or
                by inclusion.
              </xs:documentation>
            </xs:annotation>

            <xs:element name="arg">
              <xs:annotation>
                <xs:documentation xml:lang="en">
                  Declares a launch file argument.
                </xs:documentation>
              </xs:annotation>

              <xs:complexType>
                <xs:attribute name="name" type="xs:string" use="required">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">


#  ROS 2 Launch XML Format


    <node ns="sense_think_act" pkg="launch_pkg" type="sensor_node" name="sensor_node" output="screen"/>
    <node ns="sense_think_act" pkg="launch_pkg" type="compute_node" name="compute_node" output="screen"/>
    <node ns="sense_think_act" pkg="launch_pkg" type="motor_node" name="motor_node" output="screen"/>


* Launch file examples


Let’s add our three nodes to a "sense_think_act" namespace in our launch file:


[ ![Andromeda gravatar
image](/upfiles/avatars/Andromeda/resized/16/Andromeda_-_galaxy_3.jpg)
](/users/19675/andromeda/) [ Andromeda ](/users/19675/andromeda/) (
2021-07-15 12:46:36 -0500  )  edit


##  Static Description


       <!-- Three nodes -->
       <node pkg="launch_pkg" type="sensor_node" name="sensor_node" output="screen"/>
       <node pkg="launch_pkg" type="compute_node" name="compute_node" output="screen"/>
       <node pkg="launch_pkg" type="motor_node" name="motor_node" output="screen"/>
    </launch>


To test that the remapping is working, you can control the turtles by running
the following command in another terminal:


tutorial


Contributors


Next, use the ` node ` tag to declare each of your nodes and close the `
launch ` tag:


[ Get started for free ](https://app.foxglove.dev/signup)


##  Using the Launch files from the command line  ï


##  Launch file examples  ï


So, I have to:


ros2 launch <package_name> <launch_file_name> background_r:=255


Will launch both the server and client from the [ <add_two_ints>
](/ROS/Tutorials/WritingServiceClient%28c%2B%2B%29) example, passing as
parameters the value _a_ and _b_ . The resulting launch project can be called
as follows:


#####  Examples


The following example shows a minimal launch configuration script. It launches
a single 'talker' node, which is part of the 'rospy_tutorials' package. This
node will launch on the local machine using the currently configured ROS
environment (i.e. ROS_ROOT, etc...).


###  Minimal Example


The ` <set_env> ` tag allows for modifying an OS process environment. It can
be used nested in ` launch ` or ` group ` tags. It allows conditional
execution.


##  Ready to try Foxglove?


[ edit ](/questions/371822/edit/) [ retag ](/s/questions/371822/retag/) flag
offensive  [ close ](/questions/371822/close/) merge  delete


###  A More Complicated Example


Email address


The reason for doing that is I want to mount a volume (which is the ROS2
workspace) from Host into a docker container.


* [ <remap> ](/roslaunch/XML/remap)


##  Example .launch XML Config Files


![José L. Millán](/images/blog/authors/joselmillan.webp) José L. Millán  José
L. Millán


  * Immutable Page
  * Comments
  * [ Info ](/action/info/roslaunch/XML?action=info)
  * [ Attachments ](/action/AttachFile/roslaunch/XML?action=AttachFile)
  * More Actions:  Raw Text  Print View  Render as Docbook  Delete Cache  \------------------------  Check Spelling  Like Pages  Local Site Map  \------------------------  Rename Page  Copy Page  Delete Page  \------------------------  My Pages  Subscribe User  \------------------------  Remove Spam  Revert to this revision  Package Pages  Sync Pages  \------------------------  CreatePdfDocument  Load  RawFile  Save  SlideShow


[ ROS 2 Documentation: Foxy ![Logo](../_static/foxy-small.png)
](../index.html)


Wiki: roslaunch/XML (last edited 2017-07-21 01:19:06 by  [ MikePurvis
](/MikePurvis "MikePurvis @ 23-233-6-110.cpe.pppoe.ca\[23.233.6.110\]") )


© Open Source Robotics Foundation, Inc.


Use Foxglove Studio’s new color modes to customize your point clouds


#####  Description


              <xs:documentation xml:lang="en">
                A predicate to condition executable launch i.e. do so unless
                the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="executable">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Executes an executable as a local OS process.
          </xs:documentation>
        </xs:annotation>
        <xs:complexType>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A collection of environment variable settings for the
                launched executable.
              </xs:documentation>
            </xs:annotation>

            <xs:element ref="env"/>
          </xs:choice>
          <xs:attribute name="cmd" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Path to the executable or a command-line if a
                shell is used to launch.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="cwd" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                The working directory for the launched process.
              </xs:documentation>
            </xs:annotation>


* [ <machine> ](/roslaunch/XML/machine)


Subscribe


**You're reading the documentation for a version of ROS 2 that has reached its
EOL (end-of-life), and is no longer officially supported. If you want up-to-
date information, please have a look at[ Iron ](../../iron/How-To-
Guides/Launch-file-different-formats.html) . **


` unless=value ` (optional)


The ` <include> ` tag allows for bringing a launch file description into
another, enabling re-use of hierarchical launch layouts. The included launch
file description has its own scope for launch configurations. The included
launch file description is not necessarily written in this format nor a
declarative one (i.e. a programmatic description).


##  Related questions


####  ` <env> ` Tag


[ Visualizing Point Clouds with Custom Colors  ](/blog/visualizing-point-
clouds-with-custom-colors)


Table of Contents


Check that your nodes are running by opening a new terminal window with ROS 2
sourced and adding Foxglove Studio's [ Topic Graph panel
](https://docs.foxglove.dev/docs/visualization/panels/topic-graph) to your
layout:


I am having difficultly understanding the difference between a normal ` colcon
build ` and ` colcon build --symlink-install ` .


Authors: [ Michel Hidalgo ](https://github.com/hidmic)


##  Question Tools


[ ROS2 Only able to run built packages from install/
](/question/377339/ros2-only-able-to-run-built-packages-from-install/)


            </xs:annotation>
            <xs:simpleType>
              <xs:restriction base="xs:string">
                <xs:pattern value="[0-9]+\.[0-9]+\.[0-9]+"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="let">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Defines a launch configuration variable.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:attribute name="name" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name of the launch configuration variable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="value" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Value for the launch configuration variable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="include">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Includes another launch file, either descriptive or programmatic.
          </xs:documentation>


Seen: **15,585 times**


##  Comments


* e.g. ` $(find rospy)/manifest.xml ` . Specifies a _package-relative path_ . The filesystem path to the package directory will be substituted inline. Use of package-relative paths is highly encouraged as hard-coded paths inhibit the portability of the launch configuration. Forward and backwards slashes will be resolved to the local filesystem convention.


ROS


Email address


###  Tags Semantics


Last Modified: 2021-06


  * [ ` sensor.cpp ` ](https://github.com/foxglove/tutorials/tree/main/ros1/launch/src/sensor.cpp)
  * [ ` compute.cpp ` ](https://github.com/foxglove/tutorials/tree/main/ros1/launch/src/compute.cpp)
  * [ ` motor.cpp ` ](https://github.com/foxglove/tutorials/tree/main/ros1/launch/src/motor.cpp)


####  ` <remap> ` Tag


    * [ Development process for a release ](../Releases/Release-Process.html)
  * [ Tutorials ](../Tutorials.html)
    * [ Beginner: CLI tools ](../Tutorials/Beginner-CLI-Tools.html)
      * [ Configuring environment ](../Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.html)
      * [ Using ` turtlesim  ` , ` ros2  ` , and ` rqt  ` ](../Tutorials/Beginner-CLI-Tools/Introducing-Turtlesim/Introducing-Turtlesim.html)
      * [ Understanding nodes ](../Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Nodes/Understanding-ROS2-Nodes.html)
      * [ Understanding topics ](../Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Topics/Understanding-ROS2-Topics.html)
      * [ Understanding services ](../Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Services/Understanding-ROS2-Services.html)
      * [ Understanding parameters ](../Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Parameters/Understanding-ROS2-Parameters.html)
      * [ Understanding actions ](../Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Actions/Understanding-ROS2-Actions.html)
      * [ Using ` rqt_console  ` to view logs ](../Tutorials/Beginner-CLI-Tools/Using-Rqt-Console/Using-Rqt-Console.html)
      * [ Launching nodes ](../Tutorials/Beginner-CLI-Tools/Launching-Multiple-Nodes/Launching-Multiple-Nodes.html)
      * [ Recording and playing back data ](../Tutorials/Beginner-CLI-Tools/Recording-And-Playing-Back-Data/Recording-And-Playing-Back-Data.html)
    * [ Beginner: Client libraries ](../Tutorials/Beginner-Client-Libraries.html)
      * [ Using ` colcon  ` to build packages ](../Tutorials/Beginner-Client-Libraries/Colcon-Tutorial.html)
      * [ Creating a workspace ](../Tutorials/Beginner-Client-Libraries/Creating-A-Workspace/Creating-A-Workspace.html)
      * [ Creating a package ](../Tutorials/Beginner-Client-Libraries/Creating-Your-First-ROS2-Package.html)
      * [ Writing a simple publisher and subscriber (C++) ](../Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Cpp-Publisher-And-Subscriber.html)
      * [ Writing a simple publisher and subscriber (Python) ](../Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Publisher-And-Subscriber.html)
      * [ Writing a simple service and client (C++) ](../Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Cpp-Service-And-Client.html)
      * [ Writing a simple service and client (Python) ](../Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Service-And-Client.html)
      * [ Creating custom msg and srv files ](../Tutorials/Beginner-Client-Libraries/Custom-ROS2-Interfaces.html)
      * [ Implementing custom interfaces ](../Tutorials/Beginner-Client-Libraries/Single-Package-Define-And-Use-Interface.html)
      * [ Using parameters in a class (C++) ](../Tutorials/Beginner-Client-Libraries/Using-Parameters-In-A-Class-CPP.html)
      * [ Using parameters in a class (Python) ](../Tutorials/Beginner-Client-Libraries/Using-Parameters-In-A-Class-Python.html)
      * [ Using ` ros2doctor  ` to identify issues ](../Tutorials/Beginner-Client-Libraries/Getting-Started-With-Ros2doctor.html)
      * [ Creating and using plugins (C++) ](../Tutorials/Beginner-Client-Libraries/Pluginlib.html)
    * [ Intermediate ](../Tutorials/Intermediate.html)
      * [ Managing Dependencies with rosdep ](../Tutorials/Intermediate/Rosdep.html)
      * [ Creating an action ](../Tutorials/Intermediate/Creating-an-Action.html)
      * [ Writing an action server and client (C++) ](../Tutorials/Intermediate/Writing-an-Action-Server-Client/Cpp.html)
      * [ Writing an action server and client (Python) ](../Tutorials/Intermediate/Writing-an-Action-Server-Client/Py.html)
      * [ Composing multiple nodes in a single process ](../Tutorials/Intermediate/Composition.html)
      * [ Launch ](../Tutorials/Intermediate/Launch/Launch-Main.html)
        * [ Creating a launch file ](../Tutorials/Intermediate/Launch/Creating-Launch-Files.html)
        * [ Integrating launch files into ROS 2 packages ](../Tutorials/Intermediate/Launch/Launch-system.html)
        * [ Using substitutions ](../Tutorials/Intermediate/Launch/Using-Substitutions.html)
        * [ Using event handlers ](../Tutorials/Intermediate/Launch/Using-Event-Handlers.html)
        * [ Managing large projects ](../Tutorials/Intermediate/Launch/Using-ROS2-Launch-For-Large-Projects.html)
      * [ ` tf2  ` ](../Tutorials/Intermediate/Tf2/Tf2-Main.html)


[ ![How to Use ROS 2 Launch Files](/images/blog/how-to-use-ros2-launch-
files/hero.webp) ](/blog/how-to-use-ros2-launch-files)


Contents


October 27, 2022  ·  9 min  read


The XML format for declarative launch descriptions in the ROS 2 launch system.


![Nodes with namespaces](/images/blog/how-to-use-ros1-launch-
files/namespaces.webp)


[ Product ](/product) [ Blog ](/blog) [ Customers ](/customers) [ Pricing
](/pricing) [ Docs ](https://docs.foxglove.dev) [ Download
](https://foxglove.dev/download) [ Sign in ](https://app.foxglove.dev/signin)
[ Get started ](https://app.foxglove.dev/signup)


  * [ Security ](/security)
  * [ Privacy ](/legal/privacy)
  * [ Terms of Service ](/legal/terms)


Asked: ** 2021-02-15 01:10:06 -0500  **


##  if and unless attributes


The ` <node> ` tag allows for executing a ROS node as a local OS process.


[ Share on Twitter
](https://twitter.com/intent/tweet?text=How%20to%20Use%20ROS%201%20Launch%20Files%3A%20https%3A%2F%2Ffoxglove.dev%2Fblog%2Fhow-
to-use-ros1-launch-files%20%40foxglove) [ Share on LinkedIn
](http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Ffoxglove.dev%2Fblog%2Fhow-
to-use-ros1-launch-files)


To remedy this limitation, all substitution commands are available as
functions _within_ ` eval ` as well:


[ Twitter  ](https://twitter.com/foxglove) [ GitHub
](https://github.com/foxglove)


                      Executable output goes to a log file.
                    </xs:documentation>
                  </xs:annotation>
                </xs:enumeration>
                <xs:enumeration value="screen">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">
                      Executable output goes to stdout.
                    </xs:documentation>
                  </xs:annotation>
                </xs:enumeration>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
          <xs:attribute name="if" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition executable launch i.e. only do
                so if the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="unless" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition executable launch i.e. do so unless
                the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="param">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Sets a ROS parameter for the enclosing node to a scalar
            value, a sequence of scalar values delimited by a known
            separator or a sequence of nested named parameters, either
            defined in place or in a file to be loaded.


##  Comments


[ ![ROS Answers logo](/m/ros/media/images/logoros.png?v=28) ](/questions/)


#####  Examples


[ **asked 2021-02-15 01:10:06 -0500  ** ](/questions/371822/revisions/)


The ` <unset_env> ` tag allows for deleting an OS process environment
variable. It can be used nested in ` launch ` or ` group ` tags. It allows
conditional execution.


* [ <group> ](/roslaunch/XML/group)


* [ Login ](/action/login/roslaunch/XML?action=login)


In the root directory of your package, create a ` launch ` folder with a `
launch_example.launch.py ` file – start by adding the ` xml ` version and `
launch ` tag:


    <?xml version="1.0"?>
    <launch>


[ ![Mahmoud Kamel gravatar
image](//www.gravatar.com/avatar/b04384d0fca4e178bbb5ab4eab3e09c6?s=16&d=identicon&r=PG)
](/users/30538/mahmoud-kamel/) [ Mahmoud Kamel ](/users/30538/mahmoud-kamel/)
(  2021-07-27 03:09:06 -0500  )  edit


Rather than launching one node at a time, **we can leverage launch files to
execute and configure multiple nodes with a single command** . You can even
pull in nodes from other packages to run different processes.


  * ` $(env ENVIRONMENT_VARIABLE) `
    * Substitute the value of a variable from the current environment. The launch will fail if environment variable is not set. This value cannot be overridden by ` <env> ` tags.


* [ ros2/launch ](https://github.com/ros2/launch) (general launch features) and [ ros2/launch_ros ](https://github.com/ros2/launch_ros) (ROS 2 specific launch features) are written in Python and thus you have lower level access to launch features that may not be exposed by XML and YAML.


The ` <remap> ` tag allows for ROS name remapping of a ` <node> ` instance.


* ` $(eval <expression>) ` allows to evaluate arbitrary complex python expressions.


##  Summary


Launch files can also group your nodes into families, or namespaces. This
makes it easier for you to keep track of and monitor your nodes' behavior.


    <arg name="publish_frequency" default="10"/>
    <arg name="output_path" description="Output path for some processing pipeline"/>


As an alternative to a programmatic approach to the ROS 2 launch system’s API,
a declarative description features a WYSIWYG approach, easier to read, audit
and maintain. This is the preferred approach for ROS 1 ` roslaunch ` launch
files, thus some degree of familiarity is expected (and relied upon).


Sort by »  [ oldest  ](/question/371822/what-is-the-use-of-symlink-install-in-
ros2-colcon-build/?sort=oldest#sort-top) [ newest  ](/question/371822/what-is-
the-use-of-symlink-install-in-ros2-colcon-build/?sort=latest#sort-top) [ most
voted  ](/question/371822/what-is-the-use-of-symlink-install-in-ros2-colcon-
build/?sort=votes#sort-top)


* Python, XML, or YAML: Which should I use?


The ` <arg> ` tag allows for launch file configuration via the command-line or
when including it via an ` <include> ` tag. Arguments are launch configuration
variables just like the ones defined by ` <let> ` tags. Arguments are limited
to the scope of their definition and thus have to be explictly passed to
included files if any.


#####  Description


  * [ API ](/docs/data-platform/api/introduction)
  * [ Status ](https://foxglovestatus.com/)
  * [ GitHub ](https://github.com/foxglove)


* Will assign the _my_foo_ argument to the _foo_ parameter.


To set the arguments that are passed to the launch file, you should use `
key:=value  ` syntax. For example, you can set the value of ` background_r  `
in the following way:


[ ![gvdhoorn gravatar image](/upfiles/avatars/gvdhoorn/resized/32/4550046.png)
](/users/5184/gvdhoorn/)


Except where otherwise noted, the ROS wiki is licensed under the
[ Creative Commons Attribution 3.0
](http://creativecommons.org/licenses/by/3.0/)


* Substitute the value of an environment variable if it is set. If ` default_value ` is provided, it will be used if the environment variable is not set. If ` default_value ` is not provided, an empty string will be used. ` default_value ` can be multiple words separated by spaces.


[ Send an array or a list between nodes? ](/question/411851/send-an-array-or-
a-list-between-nodes/)


[ Please Login to View Contributors
](https://github.com/login/oauth/authorize?client_id=efa6dd8eae9106381720)


###  Built-in Substitutions


     Substituted by the evaluated python expression. Substitution will fail if python fails to evaluate the expression.
` $(dirname) `


#####  Examples


  * [ ](../index.html)
  * [ How-to Guides ](../How-To-Guides.html)
  * Using Python, XML, and YAML for ROS 2 Launch Files
  * [ Edit on GitHub ](https://github.com/ros2/ros2_documentation/blob/foxy/source/How-To-Guides/Launch-file-different-formats.rst)


  * [ Community ](/community)
  * [ Newsletter ](/newsletter)
  * [ Schedule a demo ](/demo)
  * [ Contact us ](/contact)


We got three nodes running with a single line!


* [ ros2 ](/questions/scope:all/sort:activity-desc/tags:ros2/page:1/)


For a reference to all the code covered in this post, check out our [ `
foxglove/tutorials ` GitHub repo
](https://github.com/foxglove/tutorials/tree/main/ros1/launch) .


![Jacob Bandes-Storch](/images/blog/authors/jacobbandesstorch.webp) Jacob
Bandes-Storch  Jacob Bandes-Storch


You can also set parameters on the [ Parameter Server ](/Parameter%20Server) .
These parameters will be stored on the Parameter Server before any nodes are
launched.


> with symlink-install if you change code in your source code, it will take
> effect, you don't have to compile it again (ony with python, not c++)


[ ALL ](/questions/scope:all/sort:activity-desc/page:1/) [ UNANSWERED
](/questions/scope:unanswered/sort:answers-asc/page:1/)


[ Please Login to View Pull Requests
](https://github.com/login/oauth/authorize?client_id=efa6dd8eae9106381720)


    <launch>
      <!-- local machine already has a definition by default.
           This tag overrides the default definition with
           specific ROS_ROOT and ROS_PACKAGE_PATH values -->
      <machine name="local_alt" address="localhost" default="true" ros-root="/u/user/ros/ros/" ros-package-path="/u/user/ros/ros-pkg" />
      <!-- a basic listener node -->
      <node name="listener-1" pkg="rospy_tutorials" type="listener" />
      <!-- pass args to the listener node -->
      <node name="listener-2" pkg="rospy_tutorials" type="listener" args="-foo arg2" />
      <!-- a respawn-able listener node -->
      <node name="listener-3" pkg="rospy_tutorials" type="listener" respawn="true" />
      <!-- start listener node in the 'wg1' namespace -->
      <node ns="wg1" name="listener-wg1" pkg="rospy_tutorials" type="listener" respawn="true" />
      <!-- start a group of nodes in the 'wg2' namespace -->
      <group ns="wg2">
        <!-- remap applies to all future statements in this scope. -->
        <remap from="chatter" to="hello"/>
        <node pkg="rospy_tutorials" type="listener" name="listener" args="--test" respawn="true" />
        <node pkg="rospy_tutorials" type="talker" name="talker">
          <!-- set a private parameter for the node -->
          <param name="talker_1_param" value="a value" />
          <!-- nodes can have their own remap args -->
          <remap from="chatter" to="hello-1"/>
          <!-- you can set environment variables for a node -->
          <env name="ENV_EXAMPLE" value="some value" />
        </node>
      </group>
    </launch>


If you have a different workspace, you have to source as well. Remember that
you can source as many workspaces as you want. Run your launch file again:


And check your nodes again with Foxglove Studio:


####  ` <node> ` Tag


<executable cmd="ls -las" cwd="/home" launch-prefix="time" output="screen"/>


    # example.launch.py

    import os

    from ament_index_python import get_package_share_directory

    from launch import LaunchDescription
    from launch.actions import DeclareLaunchArgument
    from launch.actions import IncludeLaunchDescription
    from launch.actions import GroupAction
    from launch.launch_description_sources import PythonLaunchDescriptionSource
    from launch.substitutions import LaunchConfiguration
    from launch.substitutions import TextSubstitution
    from launch_ros.actions import Node
    from launch_ros.actions import PushRosNamespace

    def generate_launch_description():

        # args that can be set from the command line or a default will be used
        background_r_launch_arg = DeclareLaunchArgument(
            "background_r", default_value=TextSubstitution(text="0")
        )
        background_g_launch_arg = DeclareLaunchArgument(
            "background_g", default_value=TextSubstitution(text="255")
        )
        background_b_launch_arg = DeclareLaunchArgument(
            "background_b", default_value=TextSubstitution(text="0")
        )
        chatter_ns_launch_arg = DeclareLaunchArgument(
            "chatter_ns", default_value=TextSubstitution(text="my/chatter/ns")
        )

        # include another launch file
        launch_include = IncludeLaunchDescription(
            PythonLaunchDescriptionSource(
                os.path.join(
                    get_package_share_directory('demo_nodes_cpp'),


![All nodes in the Topic Graph panel](/images/blog/how-to-use-ros1-launch-
files/all-nodes.webp)


[ ROS2 topic list only working once (or any other command)
](/question/354512/ros2-topic-list-only-working-once-or-any-other-command/)


"$(eval arg('foo') + env('PATH') + 'bar' + find('pkg')"


    <group scoped="true">
      <node pkg="a_ros_package" name="dummy0" namespace="my_ns" exec="dummy_node"/>
      <node pkg="a_ros_package" name="dummy1" exec="dummy_node"/>
    </group>


There is also an additional very good advantage for c++. When you use IDE such
as VScode the navigation funcionality works better. For example, if you
navigate from the integrated terminal to some error in a header file, it
brings you to the source code file (instead of the install folder file)


but do you need to use ` . install/setup.bash ` anyway?


####  ` <set_env> ` Tag


|  [ Ask Your Question ](/questions/ask/)
---|---|---|---

9


[ Previous ](Launch-files-migration-guide.html "Migrating launch files from
ROS 1 to ROS 2") [ Next  ](Launching-composable-nodes.html "Using ROS 2 launch
to launch composable nodes")


    # find dependencies
    find_package(catkin REQUIRED COMPONENTS
     geometry_msgs
     roscpp
     std_msgs
    )
    # ...
    catkin_package()
    # ...
    add_executable(motor_node src/motor.cpp)
    add_executable(sensor_node src/sensor.cpp)
    add_executable(compute_node src/compute.cpp)

    target_link_libraries(motor_node
     ${catkin_LIBRARIES}
    )
    target_link_libraries(sensor_node
     ${catkin_LIBRARIES}
    )
    target_link_libraries(compute_node
     ${catkin_LIBRARIES}
    )


  *[
              2021-02-15 01:10:06 -0500
             ]: 2021-02-15 01:10:06 -0500
  *[
              2021-02-15 02:31:57 -0500
             ]: 2021-02-15 02:31:57 -0500
  *[
             2022-10-20 01:25:24 -0500
            ]: 2022-10-20 01:25:24 -0500
  *[
              2021-02-19 00:54:29 -0500
             ]: 2021-02-19 00:54:29 -0500
  *[
              2021-02-19 00:56:40 -0500
             ]: 2021-02-19 00:56:40 -0500
  *[
             2021-06-07 04:19:40 -0500
            ]: 2021-06-07 04:19:40 -0500
  *[
             2021-06-11 03:28:32 -0500
            ]: 2021-06-11 03:28:32 -0500
  *[
             2021-07-15 12:46:36 -0500
            ]: 2021-07-15 12:46:36 -0500
  *[
             2021-07-27 03:09:06 -0500
            ]: 2021-07-27 03:09:06 -0500
  *[
              2021-08-12 12:35:16 -0500
             ]: 2021-08-12 12:35:16 -0500
  *[
        2021-02-15 01:10:06 -0500
       ]: 2021-02-15 01:10:06 -0500
  *[
        2024-04-14 17:33:01 -0500
       ]: 2024-04-14 17:33:01 -0500


ros2 launch <path_to_launch_file> background_r:=255


* [ <arg> ](/roslaunch/XML/arg)


    * For your convenience, arguments are also implicitly resolved, i.e. the following two expressions are identical:

                "$(eval arg('foo'))"
        "$(eval foo)"


#####  Examples


roslaunch beginner_tutorials launch_file.launch a:=1 b:=5


    * For example:

                  <param name="foo" value="$(arg my_foo)" />


The ` <env> ` tag allows for modifying an OS process environment. It can be
used nested in ` node ` or ` executable ` tags. It doesn’t allow conditional
execution.


[ cannot import interpreter ](/question/316468/cannot-import-interpreter/)


##  Dynamic Configuration


####  ` <let> ` Tag


* [ <node> ](/roslaunch/XML/node)


This page describes the XML format used for [ roslaunch ](/roslaunch) `
.launch ` files. For background on [ roslaunch ](/roslaunch) , its
functionality, and related tools, please consult the [ roslaunch ](/roslaunch)
page first.


[ edit ](/s/answers/384347/edit/) flag offensive  delete  [ link
](/question/371822/what-is-the-use-of-symlink-install-in-ros2-colcon-
build/?answer=384347#post-id-384347 "permanent link") more


[ All blog posts ](/blog)


        * [ Introducing ` tf2  ` ](../Tutorials/Intermediate/Tf2/Introduction-To-Tf2.html)
        * [ Writing a static broadcaster (Python) ](../Tutorials/Intermediate/Tf2/Writing-A-Tf2-Static-Broadcaster-Py.html)
        * [ Writing a static broadcaster (C++) ](../Tutorials/Intermediate/Tf2/Writing-A-Tf2-Static-Broadcaster-Cpp.html)
        * [ Writing a broadcaster (Python) ](../Tutorials/Intermediate/Tf2/Writing-A-Tf2-Broadcaster-Py.html)
        * [ Writing a broadcaster (C++) ](../Tutorials/Intermediate/Tf2/Writing-A-Tf2-Broadcaster-Cpp.html)
        * [ Writing a listener (Python) ](../Tutorials/Intermediate/Tf2/Writing-A-Tf2-Listener-Py.html)
        * [ Writing a listener (C++) ](../Tutorials/Intermediate/Tf2/Writing-A-Tf2-Listener-Cpp.html)
        * [ Adding a frame (Python) ](../Tutorials/Intermediate/Tf2/Adding-A-Frame-Py.html)
        * [ Adding a frame (C++) ](../Tutorials/Intermediate/Tf2/Adding-A-Frame-Cpp.html)
        * [ Using time (Python) ](../Tutorials/Intermediate/Tf2/Learning-About-Tf2-And-Time-Py.html)
        * [ Using time (C++) ](../Tutorials/Intermediate/Tf2/Learning-About-Tf2-And-Time-Cpp.html)
        * [ Traveling in time (Python) ](../Tutorials/Intermediate/Tf2/Time-Travel-With-Tf2-Py.html)
        * [ Traveling in time (C++) ](../Tutorials/Intermediate/Tf2/Time-Travel-With-Tf2-Cpp.html)
        * [ Debugging ](../Tutorials/Intermediate/Tf2/Debugging-Tf2-Problems.html)
        * [ Quaternion fundamentals ](../Tutorials/Intermediate/Tf2/Quaternion-Fundamentals.html)
        * [ Using stamped datatypes with ` tf2_ros::MessageFilter  ` ](../Tutorials/Intermediate/Tf2/Using-Stamped-Datatypes-With-Tf2-Ros-MessageFilter.html)
      * [ Testing ](../Tutorials/Intermediate/Testing/Testing-Main.html)
        * [ Running Tests in ROS 2 from the Command Line ](../Tutorials/Intermediate/Testing/CLI.html)
        * [ Writing Basic Tests with C++ with GTest ](../Tutorials/Intermediate/Testing/Cpp.html)
        * [ Writing Basic Tests with Python ](../Tutorials/Intermediate/Testing/Python.html)
      * [ URDF ](../Tutorials/Intermediate/URDF/URDF-Main.html)
        * [ Building a visual robot model from scratch ](../Tutorials/Intermediate/URDF/Building-a-Visual-Robot-Model-with-URDF-from-Scratch.html)
        * [ Building a movable robot model ](../Tutorials/Intermediate/URDF/Building-a-Movable-Robot-Model-with-URDF.html)
        * [ Adding physical and collision properties ](../Tutorials/Intermediate/URDF/Adding-Physical-and-Collision-Properties-to-a-URDF-Model.html)
        * [ Using Xacro to clean up your code ](../Tutorials/Intermediate/URDF/Using-Xacro-to-Clean-Up-a-URDF-File.html)
        * [ Using URDF with ` robot_state_publisher  ` ](../Tutorials/Intermediate/URDF/Using-URDF-with-Robot-State-Publisher.html)
    * [ Advanced ](../Tutorials/Advanced.html)
      * [ Enabling topic statistics (C++) ](../Tutorials/Advanced/Topic-Statistics-Tutorial/Topic-Statistics-Tutorial.html)
      * [ Using Fast DDS Discovery Server as discovery protocol [community-contributed] ](../Tutorials/Advanced/Discovery-Server/Discovery-Server.html)
      * [ Implementing a custom memory allocator ](../Tutorials/Advanced/Allocator-Template-Tutorial.html)
      * [ Recording a bag from a node (C++) ](../Tutorials/Advanced/Recording-A-Bag-From-Your-Own-Node-CPP.html)
      * [ Simulators ](../Tutorials/Advanced/Simulators/Simulation-Main.html)
        * [ Webots ](../Tutorials/Advanced/Simulators/Webots/Simulation-Webots.html)
          * [ Installation (Ubuntu) ](../Tutorials/Advanced/Simulators/Webots/Installation-Ubuntu.html)
          * [ Installation (Windows) ](../Tutorials/Advanced/Simulators/Webots/Installation-Windows.html)
          * [ Installation (macOS) ](../Tutorials/Advanced/Simulators/Webots/Installation-MacOS.html)
          * [ Setting up a robot simulation (Basic) ](../Tutorials/Advanced/Simulators/Webots/Setting-Up-Simulation-Webots-Basic.html)
          * [ Setting up a robot simulation (Advanced) ](../Tutorials/Advanced/Simulators/Webots/Setting-Up-Simulation-Webots-Advanced.html)
        * [ Ignition ](../Tutorials/Advanced/Simulators/Ignition/Simulation-Ignition.html)
          * [ Setting up a robot simulation (Ignition Gazebo) ](../Tutorials/Advanced/Simulators/Ignition/Ignition.html)


As always, feel free to reach out to the Foxglove team in our [ Slack
community ](/slack) to ask questions, give us feedback, and request a topic
for the next tutorial!


Except where otherwise noted, these design documents are licensed under [
Creative Commons Attribution 3.0
](http://creativecommons.org/licenses/by/3.0/) .


[ edit ](/s/answers/372220/edit/) flag offensive  delete  [ link
](/question/371822/what-is-the-use-of-symlink-install-in-ros2-colcon-
build/?answer=372220#post-id-372220 "permanent link") more


###  Example


                so if the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="unless" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition executable launch i.e. do so unless
                the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="unset_env">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Modifies an executable process environment.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:attribute name="name" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name of the environment variable to be set.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="if" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition executable launch i.e. only do
                so if the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="unless" type="xs:string" use="optional">
            <xs:annotation>


          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A collection of nested ROS parameters to be set.
              </xs:documentation>
            </xs:annotation>

            <xs:element ref="param"/>
          </xs:choice>
          <xs:attribute name="name" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name of the ROS parameter to be set.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="value" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Value or list of values to set the the ROS parameter with.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="sep" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Value separator when dealing with list of values.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="from" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Path to the parameters file to be loaded.
              </xs:documentation>
            </xs:annotation>


#  User


[ ![ros.org](/custom/images/ros_org.png) ](/) |  [ About
](http://www.ros.org/about-ros) | [ Support ](/Support) | [ Discussion Forum
](http://discourse.ros.org/) | [ Index ](http://index.ros.org/) | [ Service
Status ](http://status.ros.org/) | [ ros @ Robotics Stack Exchange
](https://robotics.stackexchange.com/questions/tagged/ros)
---|---
![](/custom/images/menu_left.png) [
![Documentation](/custom/images/menu_documentation.png) ](/)
![](/custom/images/menu_spacer.png) [ ![Browse
Software](/custom/images/menu_browse_software.png)
](https://index.ros.org/packages) ![](/custom/images/menu_spacer.png) [
![News](/custom/images/menu_news.png) ](https://discourse.ros.org/c/general)
![](/custom/images/menu_spacer.png) [
![Download](/custom/images/menu_download.png) ](/ROS/Installation)
![](/custom/images/menu_right.png)

  * [ roslaunch ](/roslaunch)
  * [ XML ](/roslaunch/XML)


* Include another launch file in another namespace


Another great feature of launch files is the possibility to include nodes from
another package. Let's pull the ` robot_node ` node created in our [ ROS 1
parameters tutorial ](/blog/how-to-use-ros1-parameters) into our launch file
and configure it with some parameters:


December 5, 2022  ·  11 min  read


              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
          <xs:attribute name="if" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition ROS node launch i.e. only do
                so if the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="unless" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition ROS node launch i.e. do so unless
                the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>
    </xs:schema>


[ ![ gravatar image]() ]() [ ]() (  2024-04-14 17:33:01 -0500  )  edit


Get blog posts sent directly to your inbox.


Roslaunch tag attributes can make use of _substitution args_ , which roslaunch
will resolve prior to launching nodes. The currently supported substitution
args are:


[ subscribe to rss feed ](/feeds/question/371822/ "subscribe to the rss feed")


* [ Contribute ](/contribute.html)


All tags support ` if ` and ` unless ` attributes, which include or exclude a
tag based on the evaluation of a value. "1" and "true" are considered true
values. "0" and "false" are considered false values. Other values will error.


    * e.g. ` $(anon rviz-1) ` . Generates an anonymous id based on ` name ` . ` name ` itself is a unique identifier: multiple uses of ` $(anon foo) ` will create the same "anonymized" [ name ](/Names) . This is used for <node> ` name ` attributes in order to create [ nodes ](/Nodes) with anonymous [ names ](/Names) , as ROS requires nodes to have unique names. For example:

                  <node name="$(anon foo)" pkg="rospy_tutorials" type="talker.py" />
          <node name="$(anon foo)" pkg="rospy_tutorials" type="talker.py" />


###  Launching  ï


[ Please Login to View Pull Requests
](https://github.com/login/oauth/authorize?client_id=efa6dd8eae9106381720)


Start by creating a new package named ` launch_pkg ` in your ROS 1 workspace.
In the ` src ` folder, create the following files for each of your nodes:


ros2 run turtlesim turtle_teleop_key --ros-args --remap __ns:=/turtlesim1


ROS 2 launch files can be written in Python, XML, and YAML. This guide shows
how to use these different formats to accomplish the same task, as well as has
some discussion on when to use each format.


` $(dirname) ` New in Lunar


* Include another launch file


#####  Description


Built with [ Sphinx ](https://www.sphinx-doc.org/) using a [ theme
](https://github.com/readthedocs/sphinx_rtd_theme) provided by [ Read the Docs
](https://readthedocs.org) .


visualization


You can omit the ` type ` attribute if value is unambiguous. Supported types
are ` str ` , ` int ` , ` double ` , ` bool ` . You can also specify the
contents of a file instead using the ` textfile ` or ` binfile ` attributes.


    * For example:

                <include file="$(dirname)/other.launch" />


    <launch>
      <node name="talker" pkg="rospy_tutorials" type="talker" />
    </launch>


  * [ Discussions ](https://github.com/orgs/foxglove/discussions)
  * [ Slack ](/slack)
  * [ Twitter ](https://twitter.com/foxglove)


[ Powered by Askbot version 0.10.2 ](http://askbot.com)


      [ INFO] [1666977891.710717793]: Moving motors forward
      [ INFO] [1666977892.709717886]: Read value -26519
      [ INFO] [1666977892.710128518]: Received value -26519, sending -1.00
      [ INFO] [1666977892.710384523]: Received value -1.00
      [ INFO] [1666977892.710431862]: Moving motors backwards
      [ INFO] [1666977893.709804282]: Read value 18547
      [ INFO] [1666977893.710253914]: Received value 18547, sending 1.00
      [ INFO] [1666977893.710570992]: Received value 1.00
      [ INFO] [1666977893.710637276]: Moving motors forward


Launch files in ROS 1 were written in XML, so XML may be the most familiar to
people coming from ROS 1. To see whatâs changed, you can visit [ Migrating
launch files from ROS 1 to ROS 2  ](Launch-files-migration-guide.html) .


      <!-- Adding node from another package with parameters -->
      <rosparam command="load" file="$(find params_pkg)/params/warehouseA_core.yaml" />
      <node ns="core" pkg="params_pkg" type="robot_node" name="robot_node" output="screen"/>


![Topic graph](/images/blog/how-to-use-ros1-launch-files/topic-graph.webp)


also for urdf I believe. PS [ @sansevieria22 ](/users/75265/sansevieria22/)
please accept the answer as the correct answer, to remove it from the
'unanswered' list.


* [ <param> ](/roslaunch/XML/param)


[ **answered 2021-08-12 12:35:16 -0500  ** ](/answers/384347/revisions/)


Substituted by the current launch file directory name. Substitution will always succeed.


` roslaunch ` evaluates the XML file in a single pass. Includes are processed
in depth-first traversal order. Tags are evaluated serially and the **last
setting wins** . Thus, if there are multiple settings of a parameter, the last
value specified for the parameter will be used.


ROS 1 launch files can dramatically streamline your robotics development, by
making it possible to execute multiple nodes with a single command. We hope
you found this tutorial useful, and learned how to streamline your workflows
in the future!


  * Open
  * Closed


####  ` <include> ` Tag


###  Developers


            <xs:element ref="set_env"/>
            <xs:element ref="unset_env"/>
          </xs:choice>
          <xs:attribute name="scoped" type="xs:boolean" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Whether the group is a scoping one launch configuration-wise or not.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="if" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition group launch i.e. only do
                so if the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="unless" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition group launch i.e. do
                so unless the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="env">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Modifies an executable process environment.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:attribute name="name" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">


Instead of running each of these nodes in a separate terminal window each time
we startup the robot, we can use a launch file to execute them all at once –
with a single command, in a single terminal window.


add a comment


Relying on the override behavior can be brittle. There is no guarantee that an
override is specified correctly (e.g. if a parameter name is changed in an
included file). Instead, it is recommended that override behavior be done
using ` $(arg) ` / ` <arg> ` settings.


[ Rolling ](../../rolling/How-To-Guides/Launch-file-different-formats.html)


#####  Examples


[ ![drtritm gravatar image](/m/default/media/images/nophoto.png?v=28)
](/users/50806/drtritm/)


          </xs:attribute>
          <xs:assert test="(@name and not(@from)) or (not(@name) and @from)"/>
        </xs:complexType>
      </xs:element>

      <xs:element name="remap">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Remaps ROS names for a node.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:attribute name="from" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name matching expression to look for replacement candidates.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="to" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name replacement expression to replace candidates found.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="node">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Executes a ROS node executable in a local OS process.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:annotation>


* ` $(dirname) ` returns the absolute path to the directory of the launch file in which it appears. This can be used in conjunction with ` eval ` and ` if/unless ` to modify behaviour based on the installation path, or simply as a convenience for referencing ` launch ` or ` yaml ` files relative to the current file rather than relative to a package root (as with ` $(find PKG) ` ).


[ Selecting log level in ROS2 launch file ](/question/311471/selecting-log-
level-in-ros2-launch-file/)


That being said, a launch file written in Python may be more complex and
verbose than one in XML or YAML.


All substitutions are enclosed by ` $(...) ` .


##  Rationale


Date Written: 2019-09


Releases


with symlink-install if you change code in your source code, it will take
effect, you don't have to compile it again (ony with python, not c++)


     Substituted by the value of the launch configuration variable. Substitution will fail if the named argument does not exist.
` $(env <env-var> [default-value]) `


####  All Tags


In previous posts, we’ve seen how ROS 1 nodes communicate using [ topics
](/blog/the-building-blocks-of-ros1) , [ services ](/blog/creating-
ros1-services) and [ actions ](/blog/creating-ros1-actions) . We’ve also
talked about how we can configure nodes using [ parameters ](/blog/how-to-use-
ros1-parameters) . In these tutorials, we have been running nodes one by one.


The ` <let> ` tags allows for definition of scoped launch file configuration
variables.


[ ![Shiva_uchiha gravatar
image](//www.gravatar.com/avatar/915c256270c3ec84ee682e74bf18887b?s=32&d=identicon&r=PG)
](/users/37455/shiva_uchiha/)


    <group>
      <set_env name="RMW_IMPLEMENTATION" value="rmw_fastrtps_cpp"/>
    </group>


    * **Note** : As a limitation, ` $(eval) ` expressions need to span the whole attribute string. A mixture of other substitution args with ` eval ` within a single string is **not** possible:

                <param name="foo" value="$(arg foo)$(eval 6*7)bar"/>


  * [ Foxglove ](/product)
  * [ MCAP ](/mcap)


* ` $(arg foo) ` evaluates to the value specified by an [ <arg> ](/roslaunch/XML/arg) tag. There must be a corresponding [ <arg> ](/roslaunch/XML/arg) tag _in the same launch file_ that declares the arg.


          </xs:attribute>
          <xs:attribute name="name" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A name or label for the launched executable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="args" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Additional 'command-line' arguments for the executable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="shell" type="xs:boolean" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Whether to use a shell to launch or not.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="launch-prefix" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A prefix for the executable command-line if a shell is used to launch.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="output" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Output type for the launched executable.
              </xs:documentation>
            </xs:annotation>
            <xs:simpleType>
              <xs:restriction base="xs:string">
                <xs:enumeration value="log">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">


#####  Examples


![Foxglove Studio layout](/images/blog/how-to-use-ros1-launch-
files/layout.webp) _L to R, top to bottom: ROS computational graph in a[ Topic
Graph panel ](https://docs.foxglove.dev/docs/visualization/panels/topic-graph)
, raw sensor data and ` cmd_vel ` values in two [ Raw Messages panels
](https://docs.foxglove.dev/docs/visualization/panels/raw-messages) , sensor
data plotted with a [ Plot panel
](https://docs.foxglove.dev/docs/visualization/panels/plot) , `
cmd_vel.linear.x ` monitored with a [ Gauge panel
](https://docs.foxglove.dev/docs/visualization/panels/gauge) _


    <launch>
      <param name="somestring1" value="bar" />
      <!-- force to string instead of integer -->
      <param name="somestring2" value="10" type="str" />

      <param name="someinteger1" value="1" type="int" />
      <param name="someinteger2" value="2" />

      <param name="somefloat1" value="3.14159" type="double" />
      <param name="somefloat2" value="3.0" />

      <!-- you can set parameters in child namespaces -->
      <param name="wg/childparam" value="a child namespace parameter" />

      <!-- upload the contents of a file to the server -->
      <param name="configfile" textfile="$(find roslaunch)/example.xml" />
      <!-- upload the contents of a file as base64 binary to the server -->
      <param name="binaryfile" binfile="$(find roslaunch)/example.xml" />

    </launch>


Root tag of any launch file. There must only be one ` <launch> ` tag on a
given launch file.


* Will expect to find ` other.launch ` in the same directory as the launch file which it appears in.


[ ![Foxglove](/images/logo-white.svg) ](/)


[ Pablo Iñigo Blasco ](/users/356/pablo-inigo-blasco/) ![flag of
Spain](/m/default/media/images/flags/es.gif?v=28)
2982  ●  74  ●  121  ●  128  [ http://www.linkedin.co...
](http://www.linkedin.com/in/pabloinigoblasco "Pablo Iñigo Blasco's website is
http://www.linkedin.com/in/pabloinigoblasco")


Run the launch file again, and check the new results with the Topic Graph
panel – you'll see that the nodes and the topics have the namespace specified
in the launch file:


##  Python, XML, or YAML: Which should I use?  ï


The ROS Wiki is for ROS 1. Are you using ROS 2 ( [ Humble
](http://docs.ros.org/en/humble/) , [ Iron ](http://docs.ros.org/en/iron/) ,
or [ Rolling ](http://docs.ros.org/en/rolling/) )?
[ Check out the ROS 2 Project Documentation ](http://docs.ros.org)
Package specific documentation can be found on [ index.ros.org
](https://index.ros.org)


* Unless ` value ` evaluates to true (which means if ` value ` evaluates to false), include tag and its contents.


very nice! Thank you very much!


Imagine a robot following the "sense-think-act" model that runs one node for
each step. A ` sensor_node ` is in charge of reading distance data from a
sensor, a ` compute_node ` receives this data and sends a command to the
wheels, and finally a ` motor_node ` receives the command and outputs the
needed voltage to the motors.


[ **updated 2021-02-19 00:56:40 -0500  ** ](/answers/372220/revisions/)


* [ <rosparam> ](/roslaunch/XML/rosparam)


[ ![cc-by-sa](/m/default/media/images/cc-by-sa.png?v=28)
](http://creativecommons.org/licenses/by-sa/3.0/legalcode) ROS Answers is
licensed under Creative Commons Attribution 3.0 Content on this site is
licensed under a [ Creative Commons Attribution Share Alike 3.0
](http://creativecommons.org/licenses/by-sa/3.0/legalcode) license.


or run the file directly by specifying the path to the launch file


Below is a launch file implemented in Python, XML, and YAML. Each launch file
performs the following actions:


Any of the launch files above can be run with ` ros2  launch  ` . To try them
locally, you can either create a new package and use


For most applications the choice of which ROS 2 launch format comes down to
developer preference. However, if your launch file requires flexibility that
you cannot achieve with XML or YAML, you can use Python to write your launch
file. Using Python for ROS 2 launch is more flexible because of following two
reasons:


**A node has only one name, but can belong to multiple levels of namespaces**
. These namespaces can be joined with a forward slash ( ` / ` ) – all nodes
without a namespace will always have a single ` / ` before their names (e.g. `
/sensor_node ` ). All topics without a namespace specified during declaration
will inherit the node’s namespace, as seen in the previous image.


     Substituted by the path to the executable in the local filesystem. Executables are looked up in the ` lib ` directory of the package. Substitution will fail if the executable cannot be found.
` $(var <name>) `


[ How can I run ROS2 nodes in a debugger (e.g. gdb)? ](/question/267261/how-
can-i-run-ros2-nodes-in-a-debugger-eg-gdb/)


Should I delete it? or will it breaks the packages? If so, what is the best
approach to mount a workspace from Host which already built in Dockerfile?


#####  Examples


` $(arg foo) `


[ ![sansevieria22 gravatar image](/m/default/media/images/nophoto.png?v=28)
](/users/75265/sansevieria22/) [ sansevieria22 ](/users/75265/sansevieria22/)
(  2021-06-07 04:19:40 -0500  )  edit


[ ![Pablo Iñigo Blasco gravatar
image](//www.gravatar.com/avatar/239e6bcc732cc6d5a4f528d7f0c88ca2?s=32&d=identicon&r=PG)
](/users/356/pablo-inigo-blasco/)


          * Examples
    * Dynamic Configuration
      * Substitution Syntax
      * Built-in Substitutions
        * User-defined Substitutions


This will generate the ` install ` ` build ` ` log ` ` src ` directories
inside the container, which **will not** be used, as the host volume will
mount and replace it.


9 min  read


  * ROS 2 Launch XML Format
  * ROS 2 Launch XML Format v0.1.0
    * Rationale
    * Static Description
      * Schema Definition
      * Tags Semantics
        * All Tags
        * ` <launch> ` Tag
        * ` <include> ` Tag
          * Description
          * Examples
        * ` <group> ` Tag
          * Description
          * Examples
        * ` <let> ` Tag
          * Description
          * Examples
        * ` <arg> ` Tag
          * Description
          * Examples
        * ` <executable> ` Tag
          * Description
          * Examples
        * ` <node> ` Tag
          * Description
          * Examples
        * ` <param> ` Tag
          * Description
          * Examples
        * ` <remap> ` Tag
          * Description
          * Examples
        * ` <env> ` Tag
          * Description
          * Examples
        * ` <set_env> ` Tag
          * Description
          * Examples
        * ` <unset_env> ` Tag
          * Description


* [ <include> ](/roslaunch/XML/include)


In Development


[ **updated 2021-02-15 02:31:57 -0500  ** ](/questions/371822/revisions/)


* [ <launch> ](/roslaunch/XML/launch)


ros2 launch <package_name> <launch_file_name>


**Substitution args are currently resolved on the local machine.** In other
words, environment variables and ROS package paths will be set to their values
in your current environment, **even for remotely launched processes** .


                      Name of the launch argument.
                    </xs:documentation>
                  </xs:annotation>
                </xs:attribute>
                <xs:attribute name="value" type="xs:string" use="optional">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">
                      Fixed value for the launch argument, disables overrides.
                    </xs:documentation>
                  </xs:annotation>
                </xs:attribute>
                <xs:attribute name="default" type="xs:string" use="optional">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">
                      Default value for the launch argument, used if non is provided.
                    </xs:documentation>
                  </xs:annotation>
                </xs:attribute>
                <xs:attribute name="description" type="xs:string" use="optional">
                  <xs:annotation>
                    <xs:documentation xml:lang="en">
                      Brief description of the launch argument.
                    </xs:documentation>
                  </xs:annotation>
                </xs:attribute>
              </xs:complexType>
            </xs:element>
            <xs:element ref="let"/>
            <xs:element ref="node"/>
            <xs:element ref="executable"/>
            <xs:element ref="include"/>
            <xs:element ref="group"/>
            <xs:element ref="set_env"/>
            <xs:element ref="unset_env"/>
          </xs:choice>
          <xs:attribute name="version" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Launch XML schema version in use.
              </xs:documentation>


tutorial


##  Including nodes from other packages


Every tag’s execution can be conditioned on a boolean predicate via ` if ` or
` unless ` attributes.


1 follower


#####  Examples


[ Login disabled for now ]()


Python  XML  YAML


![Esther Weon](/images/blog/authors/estherweon.webp) Esther Weon  Esther Weon


  * [ About ](/about)
  * [ Blog ](/blog)
  * [ Careers ](/careers)
  * [ Customers ](/customers)
  * [ Media ](/media)


[ tags ](/tags/) [ users ](/users/) [ badges ](/badges/)


####  ` <param> ` Tag


* Create a node to remap messages from one topic to another


            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="if" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition launch inclusion i.e. only do
                so if the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="unless" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition launch inclusion i.e. do
                so unless the predicate evaluates to a truthy value.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="group">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Groups and optionally scopes a set of actions.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:choice minOccurs="1" maxOccurs="unbounded">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                The actions that make up the group.
              </xs:documentation>
            </xs:annotation>
            <xs:element ref="executable"/>
            <xs:element ref="node"/>
            <xs:element ref="group"/>
            <xs:element ref="include"/>
            <xs:element ref="let"/>


  * Examples:
    *           <param name="foo" value="$(optenv NUM_CPUS 1)" />
          <param name="foo" value="$(optenv CONFIG_PATH /home/marvin/ros_workspace)" />
          <param name="foo" value="$(optenv VARIABLE ros rocks)" />


  * [ Installation ](../Installation.html)
    * [ Ubuntu (Debian) ](../Installation/Ubuntu-Install-Debians.html)
    * [ Windows (binary) ](../Installation/Windows-Install-Binary.html)
    * [ Alternatives ](../Installation/Alternatives.html)
      * [ Ubuntu (source) ](../Installation/Alternatives/Ubuntu-Development-Setup.html)
      * [ Ubuntu (binary) ](../Installation/Alternatives/Ubuntu-Install-Binary.html)
      * [ Windows (source) ](../Installation/Alternatives/Windows-Development-Setup.html)
      * [ macOS (source) ](../Installation/Alternatives/macOS-Development-Setup.html)
      * [ macOS (binary) ](../Installation/Alternatives/macOS-Install-Binary.html)
      * [ Fedora (source) ](../Installation/Alternatives/Fedora-Development-Setup.html)
      * [ Latest development (source) ](../Installation/Alternatives/Latest-Development-Setup.html)
    * [ Maintain source checkout ](../Installation/Maintaining-a-Source-Checkout.html)
    * [ Testing with pre-release binaries ](../Installation/Testing.html)
    * [ DDS implementations ](../Installation/DDS-Implementations.html)
      * [ Connext security plugins ](../Installation/DDS-Implementations/Install-Connext-Security-Plugins.html)
      * [ RTI Connext DDS ](../Installation/DDS-Implementations/Install-Connext-University-Eval.html)
      * [ Eclipse Cyclone DDS ](../Installation/DDS-Implementations/Working-with-Eclipse-CycloneDDS.html)
      * [ GurumNetworks GurumDDS ](../Installation/DDS-Implementations/Working-with-GurumNetworks-GurumDDS.html)
      * [ eProsima Fast DDS ](../Installation/DDS-Implementations/Working-with-eProsima-Fast-DDS.html)
  * [ Distributions ](../Releases.html)
    * [ Iron Irwini ( ` iron  ` ) ](../Releases/Release-Iron-Irwini.html)
      * [ Iron Irwini Changelog ](../Releases/Iron-Irwini-Complete-Changelog.html)
    * [ Humble Hawksbill ( ` humble  ` ) ](../Releases/Release-Humble-Hawksbill.html)
      * [ Humble Hawksbill changelog ](../Releases/Humble-Hawksbill-Complete-Changelog.html)
    * [ Rolling Ridley ( ` rolling  ` ) ](../Releases/Release-Rolling-Ridley.html)
    * [ Development Distribution ](../Releases/Development.html)
      * [ Jazzy Jalisco (codename âjazzyâ; May, 2024) ](../Releases/Release-Jazzy-Jalisco.html)
    * [ End-of-Life Distributions ](../Releases/End-of-Life.html)
      * [ Galactic Geochelone ( ` galactic  ` ) ](../Releases/Release-Galactic-Geochelone.html)
        * [ Galactic Geochelone changelog ](../Releases/Galactic-Geochelone-Complete-Changelog.html)
      * [ Foxy Fitzroy ( ` foxy  ` ) ](../Releases/Release-Foxy-Fitzroy.html)
      * [ Eloquent Elusor ( ` eloquent  ` ) ](../Releases/Release-Eloquent-Elusor.html)
      * [ Dashing Diademata ( ` dashing  ` ) ](../Releases/Release-Dashing-Diademata.html)
      * [ Crystal Clemmys ( ` crystal  ` ) ](../Releases/Release-Crystal-Clemmys.html)
      * [ Bouncy Bolson ( ` bouncy  ` ) ](../Releases/Release-Bouncy-Bolson.html)
      * [ Ardent Apalone ( ` ardent  ` ) ](../Releases/Release-Ardent-Apalone.html)
      * [ Beta 3 ( ` r2b3  ` ) ](../Releases/Beta3-Overview.html)
      * [ Beta 2 ( ` r2b2  ` ) ](../Releases/Beta2-Overview.html)
      * [ Beta 1 ( ` Asphalt  ` ) ](../Releases/Beta1-Overview.html)
      * [ Alphas ](../Releases/Alpha-Overview.html)


[ __ ](/questions/) |


` $(find-pkg-prefix <pkg-name>) `


###  Substitution Syntax


    - include:
        file: "$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener.launch.py"

    # include another launch file in the chatter_ns namespace
    - group:
        - push-ros-namespace:
            namespace: "$(var chatter_ns)"
        - include:
            file: "$(find-pkg-share demo_nodes_cpp)/launch/topics/talker_listener.launch.py"

    # start a turtlesim_node in the turtlesim1 namespace
    - node:
        pkg: "turtlesim"
        exec: "turtlesim_node"
        name: "sim"
        namespace: "turtlesim1"

    # start another turtlesim_node in the turtlesim2 namespace and use args to set parameters
    - node:
        pkg: "turtlesim"
        exec: "turtlesim_node"
        name: "sim"
        namespace: "turtlesim2"
        param:
        -
          name: "background_r"
          value: "$(var background_r)"
        -
          name: "background_g"
          value: "$(var background_g)"
        -
          name: "background_b"
          value: "$(var background_b)"

    # perform remap so both turtles listen to the same command topic
    - node:
        pkg: "turtlesim"
        exec: "mimic"
        name: "mimic"
        remap:


                Name of the environment variable to be set.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="value" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Value to be set for the environment variable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
        </xs:complexType>
      </xs:element>

      <xs:element name="set_env">
        <xs:annotation>
          <xs:documentation xml:lang="en">
            Modifies an executable process environment.
          </xs:documentation>
        </xs:annotation>

        <xs:complexType>
          <xs:attribute name="name" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Name of the environment variable to be set.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="value" type="xs:string" use="required">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                Value to be set for the environment variable.
              </xs:documentation>
            </xs:annotation>
          </xs:attribute>
          <xs:attribute name="if" type="xs:string" use="optional">
            <xs:annotation>
              <xs:documentation xml:lang="en">
                A predicate to condition executable launch i.e. only do


###  Get in touch


##  Adding namespaces


Executing the launch file will parse this file and run the list of nodes.
Everything else happens behind the curtains of ROS 1.


In this tutorial, we will cover how to use a launch file to run multiple
nodes, configure them, and group them into meaningful namespaces.


* Will compute the circumference from the _radius_ argument and assign the result to an appropriate parameter.


Pull Requests


    <node pkg="my_pkg" exec="my_node">
      <env name="RMW_IMPLEMENTATION" value="rmw_fastrtps_cpp"/>
    </node>

    <executable cmd="ls" cwd="/var/log">
      <env name="LD_LIBRARY" value="/lib/some.so"/>
    </executable>


Made with  by [ Foxglove ](/about)


#####  Description


* Python is a scripting language, and thus you can leverage the language and its libraries in your launch files.


Running many ROS 1 nodes takes a lot of time and many terminal windows. Even
small projects or robots can have many nodes running simultaneously.


####  ` <group> ` Tag


* Setup command line arguments with defaults


__ [ ROS 2 Documentation: Foxy ](../index.html)


#####  Examples


##  substitution args


what is the use of --symlink-install in ROS2 colcon build?


` $(eval <expression>) ` New in Kinetic


[ ROS2 nav2_turorial on win10 ERROR! ](/question/418092/ros2-nav2_turorial-on-
win10-error/)


     Substituted by the install prefix path of the given package. Forward and backwards slashes will be resolved to the local filesystem convention. Substitution will fail if the package cannot be found.
` $(find-pkg-share <pkg-name>) `


##  Creating a launch file


    <let name="foo" value="$(env BAR)"/>
    <let name="baz" value="false"/>


Open menu


Note


The site is read-only. Please transition to use Robotics Stack Exchange


                    'launch/topics/talker_listener.launch.py'))
        )
        # include another launch file in the chatter_ns namespace
        launch_include_with_namespace = GroupAction(
            actions=[
                # push-ros-namespace to set namespace of included nodes
                PushRosNamespace(LaunchConfiguration('chatter_ns')),
                IncludeLaunchDescription(
                    PythonLaunchDescriptionSource(
                        os.path.join(
                            get_package_share_directory('demo_nodes_cpp'),
                            'launch/topics/talker_listener.launch.py'))
                ),
            ]
        )

        # start a turtlesim_node in the turtlesim1 namespace
        turtlesim_node = Node(
                package='turtlesim',
                namespace='turtlesim1',
                executable='turtlesim_node',
                name='sim'
            )

        # start another turtlesim_node in the turtlesim2 namespace
        # and use args to set parameters
        turtlesim_node_with_parameters = Node(
                package='turtlesim',
                namespace='turtlesim2',
                executable='turtlesim_node',
                name='sim',
                parameters=[{
                    "background_r": LaunchConfiguration('background_r'),
                    "background_g": LaunchConfiguration('background_g'),
                    "background_b": LaunchConfiguration('background_b'),
                }]
            )

        # perform remap so both turtles listen to the same command topic
        forward_turtlesim_commands_to_second_turtlesim_node = Node(


* Start a node, setting its namespace, and setting parameters in that node (using the args)


ros2 launch <path_to_launch_file>


      </group>

      <!-- start a turtlesim_node in the turtlesim1 namespace -->
      <node pkg="turtlesim" exec="turtlesim_node" name="sim" namespace="turtlesim1"/>
      <!-- start another turtlesim_node in the turtlesim2 namespace
          and use args to set parameters -->
      <node pkg="turtlesim" exec="turtlesim_node" name="sim" namespace="turtlesim2">
        <param name="background_r" value="$(var background_r)"/>
        <param name="background_g" value="$(var background_g)"/>
        <param name="background_b" value="$(var background_b)"/>
      </node>
      <!-- perform remap so both turtles listen to the same command topic -->
      <node pkg="turtlesim" exec="mimic" name="mimic">
        <remap from="/input/pose" to="/turtlesim1/turtle1/pose"/>
        <remap from="/output/cmd_vel" to="/turtlesim2/turtle1/cmd_vel"/>
      </node>
    </launch>

    # example.launch.yaml

    launch:

    # args that can be set from the command line or a default will be used
    - arg:
        name: "background_r"
        default: "0"
    - arg:
        name: "background_g"
        default: "255"
    - arg:
        name: "background_b"
        default: "0"
    - arg:
        name: "chatter_ns"
        default: "my/chatter/ns"

    # include another launch file


    <include file="/opt/my_launch_file.py"/>
    <include file="$(find-pkg-share my_pkg)/launch/some_launch_file.xml"/>
    <include file="/opt/my_other_launch_file.xml">
      <arg name="some_argument" value="dummy_value"/>
    </include>


` $(anon name) `


Hi base on this question, I would like to ask could I remove the ` src ` ` log
` ` build ` directories after ` colcon build --symlink-install ` ?


First time here? Check out the FAQ!


TBD


ROS Resources: [ Documentation ](http://wiki.ros.org/) | [ Support
](http://wiki.ros.org/Support) | [ Discussion Forum
](http://discourse.ros.org/) | [ Index ](http://index.ros.org/) | [ Service
Status ](http://status.ros.org/) | [ ros @ Robotics Stack Exchange
](https://robotics.stackexchange.com/questions/tagged/ros)
---

_Attention:_ Answers.ros.org is deprecated as of August the 11th, 2023. Please
visit [ robotics.stackexchange.com ](http://robotics.stackexchange.com) to ask
a new question. This site will remain online in read-only mode during the
transition and into the foreseeable future. Selected questions and answers
have been migrated, and redirects have been put in place to direct users to
the corresponding questions on Robotics Stack Exchange. Additional details are
[ available here ](https://discourse.ros.org/t/ros-and-gazebo-answers-
migration-to-robotics-stack-exchange-process/31494) .


Executing and configuring multiple ROS 1 nodes at once


Other Versions  v: foxy


    * Another example:

                <node name="add_two_ints_server" pkg="beginner_tutorials" type="add_two_ints_server" />
        <node name="add_two_ints_client" pkg="beginner_tutorials" type="add_two_ints_client" args="$(arg a) $(arg b)" />


#####  Description


    * [ Building ROS 2 with tracing instrumentation ](Building-ROS-2-with-Tracing-Instrumentation.html)
    * [ Topics vs Services vs Actions ](Topics-Services-Actions.html)
    * [ Using variants ](Using-Variants.html)
    * [ Using the ` ros2  param  ` command-line tool ](Using-ros2-param.html)
    * [ ROS 2 on Raspberry Pi ](Installing-on-Raspberry-Pi.html)
    * [ Using Callback Groups ](Using-callback-groups.html)
    * [ Setup ROS 2 with VSCode and Docker [community-contributed] ](Setup-ROS-2-with-VSCode-and-Docker-Container.html)
    * [ Building RQt from source ](RQt-Source-Install.html)
      * [ Building RQt from source on macOS ](RQt-Source-Install-MacOS.html)
      * [ Building RQt from source on Windows 10 ](RQt-Source-Install-Windows10.html)
  * [ Concepts ](../Concepts.html)
    * [ The ROS_DOMAIN_ID ](../Concepts/About-Domain-ID.html)
    * [ About different ROS 2 DDS/RTPS vendors ](../Concepts/About-Different-Middleware-Vendors.html)
    * [ About logging and logger configuration ](../Concepts/About-Logging.html)
    * [ About Quality of Service settings ](../Concepts/About-Quality-of-Service-Settings.html)
    * [ About ROS 2 client libraries ](../Concepts/About-ROS-2-Client-Libraries.html)
    * [ About ROS 2 interfaces ](../Concepts/About-ROS-Interfaces.html)
    * [ About parameters in ROS 2 ](../Concepts/About-ROS-2-Parameters.html)
    * [ Executors ](../Concepts/About-Executors.html)
    * [ About topic statistics ](../Concepts/About-Topic-Statistics.html)
    * [ Introspection with command line tools ](../Concepts/About-Command-Line-Tools.html)
    * [ Overview and usage of RQt ](../Concepts/About-RQt.html)
    * [ About Composition ](../Concepts/About-Composition.html)
    * [ On the mixing of ament and catkin (catment) ](../Concepts/About-Catment.html)
    * [ About Cross-compilation ](../Concepts/About-Cross-Compilation.html)
    * [ About tf2 ](../Concepts/About-Tf2.html)
    * [ About the build system ](../Concepts/About-Build-System.html)
    * [ About internal ROS 2 interfaces ](../Concepts/About-Internal-Interfaces.html)
    * [ About ROS 2 middleware implementations ](../Concepts/About-Middleware-Implementations.html)
    * [ About ROS 2 client libraries ](../Concepts/About-ROS-2-Client-Libraries.html)
  * [ Contact ](../Contact.html)
  * [ The ROS 2 Project ](../The-ROS2-Project.html)
    * [ Contributing ](../The-ROS2-Project/Contributing.html)
      * [ ROS 2 developer guide ](../The-ROS2-Project/Contributing/Developer-Guide.html)
      * [ Code style and language versions ](../The-ROS2-Project/Contributing/Code-Style-Language-Versions.html)
      * [ Quality guide: ensuring code quality ](../The-ROS2-Project/Contributing/Quality-Guide.html)
      * [ Migration guide from ROS 1 ](../The-ROS2-Project/Contributing/Migration-Guide.html)
        * [ Python migration guide from ROS 1 ](../The-ROS2-Project/Contributing/Migration-Guide-Python.html)
      * [ ROS Build Farms ](../The-ROS2-Project/Contributing/Build-Farms.html)
      * [ Windows Tips and Tricks ](../The-ROS2-Project/Contributing/Windows-Tips-and-Tricks.html)


Catch our latest news and features, sent directly to your inbox.


[ none ](/questions/scope:all/sort:activity-desc/tags:none/page:1/) ×


    * For example:

                <param name="circumference" value="$(eval 2.* 3.1415 * arg('radius'))"/>


Will generate an error that there are two <node>s with the same name.


[ View Source ](https://github.com/ros2/design/blob/gh-
pages/articles/151_roslaunch_xml.md) [ Edit in Github
](https://github.com/ros2/design/edit/gh-pages/articles/151_roslaunch_xml.md)


Last updated: **Oct 20 '22**


##  Evaluation order


Example:


* Start a node and setting its namespace


###  Setting arguments  ï


[ ![](/custom/images/brought_by_horiz.png) ](https://www.openrobotics.org/)


     [ Iron (latest) ](../../iron/How-To-Guides/Launch-file-different-formats.html)
     [ Humble ](../../humble/How-To-Guides/Launch-file-different-formats.html)
     [ Galactic (EOL) ](../../galactic/How-To-Guides/Launch-file-different-formats.html)
     [ Foxy (EOL) ](Launch-file-different-formats.html)
     [ Eloquent (EOL) ](../../eloquent/index.html)
     [ Dashing (EOL) ](../../dashing/index.html)
     [ Crystal (EOL) ](../../crystal/index.html)


#  Page