<<PackageHeader(rosmake)>>
<<TableOfContents()>>

`rosmake` is a tool to assist with building ROS [[Packages|packages]].  It facilitates building packages that have dependencies.

ROS comprises a large number of packages.  However, with the exception of some core packages that everything else depends on, e.g., [[roscpp]] and [[rospy]], many of the packages are largely independent.  As such, we have provided a [[rosbuild|build system]] to allow you to only build what is actually necessary to run the packages that you want to run.

A package may depend on any number of other packages, requiring that those packages be built first.  These dependencies are specified in the package's [[Manifest|manifest.xml]] file.  However, it would be inconvenient to make you go and look at the dependencies for your package, and then in turn look at the dependencies for those packages and so on.  Instead, we provide `rosmake` to do the ROS-wide build of everything you need for a given package.

For example, to build the `move_base` package, you can simply run:
{{{
$ rosmake move_base
}}}
`rosmake` will determine `move_base`'s dependencies (and the dependencies' dependencies, etc.), and will ensure that all dependencies are built prior to building `move_base`.

If rosmake fails, there is a good chance you are missing [[rosdep|system dependencies]] for one or more of the packages you are trying to install.

NOTE: you can run `rosmake` from anywhere, as it uses [[rospack]] to locate packages.

If you really just want to build a package, and you know that its dependencies are up-to-date, you just type '''make''' in that package's top-level directory.

You '''should not''' run `rosmake` multiple times simultaneously on one machine, unless you are sure that the builds don't share any dependencies.  You may end up building the same package simultaneously, which can cause various problems.

== Usage ==
{{{
Usage: rosmake [options] [PACKAGE]...

Options:
  -h, --help            show this help message and exit
  --test-only           only run tests
  -t                    build and test packages
  -a, --all             select all packages
  -i, --mark-installed  On successful build, mark packages as installed with
                        ROS_NOBUILD
  -u, --unmark-installed
                        Remove ROS_NOBUILD from the specified packages.  This
                        will not build anything.
  -v                    display errored builds
  -r, -k, --robust      do not stop build on error
  --build-everything    build all packages regardless of errors
  -V                    display all builds
  -s, --specified-only  only build packages specified on the command line
  --buildtest=BUILDTEST
                        package to buildtest
  --buildtest1=BUILDTEST1
                        package to buildtest1
  --output=OUTPUT_DIR   where to output results
  --pre-clean           run make clean first
  --bootstrap           Do the bootstrap packages even if there are no
                        arguments
  --disable-logging     turn off all logs
  --target=TARGET       run make with this target
  --pjobs=ROS_PARALLEL_JOBS
                        Override ROS_PARALLEL_JOBS environment variable with
                        this number of jobs.
  --threads=THREADS     Build up to N packages in parallel
  --profile             print time profile after build
  --skip-blacklist      skip packages containing a file called
                        ROS_BUILD_BLACKLIST (Default behavior will ignore the
                        presence of ROS_BUILD_BLACKLIST)
  --skip-blacklist-osx  deprecated option. it will do nothing, please use
                        platform declarations and --require-platform instead
  --require-platform    do not build a package unless it is marked as
                        supported on this platform
  --require-platform-recursive
                        do not build a package unless it is marked as
                        supported on this platform, and all dependents are
                        also marked
  --status-rate=STATUS_UPDATE_RATE
                        How fast to update the status bar in Hz.  Default: 5Hz
}}}

Options available in ROS Electric and earlier: {{{
  --rosdep-install      call rosdep install before running
  --rosdep-yes          call rosdep install with default yes argument
  --no-rosdep           disable the default check of rosdep
}}}

`rosmake` runs recursively on the dependencies of the given package(s), eventually running `make` on a each one.  After all dependencies are built, `rosmake` will build the given package(s).  If no package is given, it will try to build the current directory, which must contain a [[Manifest|manifest.xml]].

== Parallelization ==
There are two parallelization options within `rosmake`:

`parallel threads`
  `rosmake` will spawn multiple threads and build packages in parallel
`parallel jobs`
  `rosmake` will run make with the `ROS_PARALLEL_JOBS` environment variable set to `-jN`, where `N` is a number

== Modifications of Behavior ==

You can modify the behavior of `rosmake` by placing files with special names in your directory tree. These file names and their associated behaviors are described below.

=== ROS_NOBUILD ===

`rosmake` will skip packages with `ROS_NOBUILD` in the root of the package.

=== ROS_BUILD_BLACKLIST ===

`rosmake` will skip packages with a file `ROS_BUILD_BLACKLIST` in the root of the package if the option --skip-blacklist is enabled.

=== platform tag ===
If the options `--require-platform` only packages which declare the detected OS in their manifest (as demonstrated below) will be built.

{{{
<platform os="ubuntu" version="9.10"/>
}}}

`--require-platform-recursive`
  Requires that the package as well as all dependent packages have declared the specific platform as supported.