# ros-industrial/universal_robot for ROS Noetic

> A ROS-Industrial metapackage for Universal Robots descriptions, MoveIt! configurations, kinematics, and Gazebo bringup. It serves ROS Melodic and Noetic developers, while real hardware control is delegated to separate driver repositories.

**ros-industrial/universal_robot** — ROS-Industrial Universal Robots support (https://wiki.ros.org/universal_robot)

- Repository: https://github.com/ros-industrial/universal_robot
- Stars: 1,428 · Forks: 1,065
- Language: C++
- License: not declared
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/ros-industrial-universal-robot

## What universal_robot Provides for ROS Users

ros-industrial/universal_robot is a ROS-Industrial metapackage for Universal Robots. Its purpose is to make robot descriptions and related ROS components available to applications built around ROS, rather than to provide a general-purpose robot controller. The repository includes a `universal_robots` package, a `ur_description` package, a `ur_gazebo` package, a `ur_kinematics` package, and separate MoveIt! configuration packages for robot models including UR3, UR3e, UR5, UR5e, UR7e, UR8long, UR10, UR10e, UR12e, UR15, UR16e, UR18, UR20, and UR30.

The intended users are ROS developers working with Universal Robots in simulation, motion planning, visualization, or integration with other ROS-Industrial packages. The README explicitly identifies the project as a metapackage and points readers to the ROS wiki for compatibility information. It also carries a community support label, so it should be understood as community-maintained software rather than as a support contract from Universal Robots.

The repository does not present itself as a complete hardware stack. For real hardware, the README directs users to the separate `ur_robot_driver` repository. Older robots running Software CB1 or CB2 are directed to `ur_modern_driver`. This separation matters for adoption: this repository supplies the model, simulation, and motion-planning layers, while the driver repository handles the real-robot interface documented there.

## Package Layout and ROS Data Flow

The repository layout indicates a package-oriented ROS Catkin workspace rather than a single executable. `ur_description` contains robot description resources and meshes. The listed MoveIt! packages provide model-specific configuration, while `ur_kinematics` is the package associated with kinematics. `ur_gazebo` contains launch resources for simulated robot startup.

For simulation, the documented path starts with a model-specific Gazebo launch file. The command uses the UR5 as its example and loads the simulated robot through `ur_gazebo`. Once the simulation is running, a MoveIt! launch file can start motion planning with `sim:=true`. RViz can then be started with a second MoveIt! configuration launch. The README does not describe message-level internals, controller details, or a custom transport protocol, so the exact data flow beyond these ROS launch and configuration boundaries is not established.

For real hardware, the README does not ask users to launch this repository as the controller. It points to `ur_robot_driver`, whose installation and startup instructions are maintained separately. That is an architectural boundary rather than a missing example. Consumers can use the descriptions and MoveIt! configuration while leaving device access, startup, and hardware-specific communication to the selected driver.

## Installing the Binary Package on Ubuntu

For Ubuntu and Debian systems covered by the README, the preferred installation method is the binary distribution. The README names Ubuntu 18.04 Bionic and Ubuntu 20.04 Focal, with `i386` and `amd64`, and says to select the ROS distribution already installed on the machine. The package name is derived from that distribution.

The documented command is:

```bash
sudo apt-get install ros-$ROS_DISTRO-universal-robots
```

Replace `$ROS_DISTRO` with `melodic` or `noetic`. The README prefers the binary release where possible because source installations are not automatically updated by new package releases and require more setup work. The repository has no GitHub releases listed, so the binary package and source branch should not be confused with a GitHub release artifact.

The command installs the ROS package into the configured apt and ROS environment. It does not by itself prove that the active robot is connected, configured, or ready for motion. Real hardware still requires the separate driver repository and its startup instructions. Gazebo and MoveIt! also require the relevant ROS environment to be sourced.

## Building noetic-devel in a Catkin Workspace

When a binary package is not suitable, the README provides a source workflow based on a Catkin workspace at `$HOME/catkin_ws`. The source branch name is tied to the ROS distribution, so `$ROS_DISTRO-devel` is used in the clone command. The repository's default branch is `noetic-devel`, but the documented command explicitly uses the branch expression shown below.

Retrieve the repository with this command:

```bash
cd $HOME/catkin_ws/src
```

```bash
git clone -b $ROS_DISTRO-devel https://github.com/ros-industrial/universal_robot.git
```

From the workspace root, update the dependency database:

```bash
cd $HOME/catkin_ws
```

```bash
rosdep update
```

Install dependencies from the source paths:

```bash
rosdep install --rosdistro $ROS_DISTRO --ignore-src --from-paths src
```

Build the workspace and activate it:

```bash
catkin_make
```

```bash
source $HOME/catkin_ws/devel/setup.bash
```

The README warns that source builds require more work and are not automatically updated by package releases. It also says binary releases are preferred where possible. The README does not give a compatibility matrix for every model and ROS version, so users should check the ROS wiki before assuming that every listed package works with every distribution.

## First Gazebo and MoveIt! Launch

The first documented use is a simulated UR5. The README says to source the correct setup files and use a new terminal for each command. That instruction is important because the generated Catkin workspace setup must be present in the shell that starts the launch.

Bring up the simulated robot with this command:

```bash
roslaunch ur_gazebo ur5_bringup.launch
```

This should start the Gazebo simulation for the UR5 example. The README does not document expected console output, a success message, or a verification procedure, so the command itself and the visible Gazebo model are the concrete checks available.

After the simulated robot is available, start motion planning with MoveIt! using the explicit simulation flag:

```bash
roslaunch ur5_moveit_config moveit_planning_execution.launch sim:=true
```

For visualization and the MoveIt! Motion Planning plugin, the documented RViz command is:

```bash
roslaunch ur5_moveit_config moveit_rviz.launch
```

The same prefix can be changed for another model where a corresponding configuration package exists. That is the practical boundary of the example. The README does not explain parameter selection, controller tuning, collision-scene creation, or how to move the simulated arm.

## Driver Selection, Limits, and Licence Boundaries

The clearest limitation is hardware scope. This repository does not document a complete production driver for physical Universal Robots. The README says to use `ur_robot_driver` for real hardware and `ur_modern_driver` for older robots running Software CB1 or CB2. Selecting the wrong driver category could leave an application without the expected hardware startup path.

There is also a version boundary. The binary instructions name Ubuntu 18.04 Bionic and 20.04 Focal and ROS Melodic or Noetic, while the compatibility wiki is the stated place for current compatibility information. The README does not promise support for newer operating systems or newer ROS distributions. Repository maintenance information should also be separated from package compatibility: the last push was on 2026-07-20, which indicates recent repository activity, but it does not guarantee that every model package or hardware driver has the same release cadence.

Licensing is not uniform across the repository. The README states that all other content is licensed under BSD-3-Clause or Apache-2.0, respectively. It separately identifies the UR8LONG, UR15, UR18, UR20, and UR30 meshes as Universal Robots Graphical Documentation governed by Universal Robots' Terms and Conditions for use of Graphical Documentation. Those terms permit use, modification, and sharing subject to restrictions, but the README says they do not fully comply with the OSI definition of open source. This is a distribution and compliance decision, not a technical capability, and the applicable terms should be reviewed for the intended use case.

A real alternative is to use a driver repository directly for hardware and treat this metapackage as optional support for descriptions and planning. `ur_robot_driver` is the documented route for current real-hardware integration, while this repository supplies the URDF, MoveIt!, kinematics, and Gazebo pieces. The choice depends on whether the application needs hardware communication or the model and planning layer.

## Conclusion

Adopt ros-industrial/universal_robot when a ROS Melodic or Noetic application needs Universal Robots descriptions, MoveIt! configurations, or Gazebo bringup. Do not treat it as a standalone hardware driver, because the README directs real-robot users to ur_robot_driver or ur_modern_driver. Verify ROS distribution compatibility, the selected robot configuration package, driver choice, and the licensing of the specific mesh assets before building the workspace.

## FAQ

### How do I install ros-industrial/universal_robot on Ubuntu?

The README gives the command `sudo apt-get install ros-$ROS_DISTRO-universal-robots` for supported Ubuntu and Debian systems. Replace `$ROS_DISTRO` with `melodic` or `noetic`, depending on the installed ROS version.

### Can ros-industrial/universal_robot control a real Universal Robot?

The repository is a ROS-Industrial metapackage and does not present itself as the complete hardware driver. The README directs users to `ur_robot_driver` for real hardware and `ur_modern_driver` for older Software CB1 or CB2 robots.

### How do I start a simulated UR5 with Gazebo and MoveIt!?

The README documents `roslaunch ur_gazebo ur5_bringup.launch`, followed by `roslaunch ur5_moveit_config moveit_planning_execution.launch sim:=true` for motion planning and `roslaunch ur5_moveit_config moveit_rviz.launch` for RViz.

## Sources

- [Issues](https://github.com/ros-industrial/universal_robot/issues)
- [README](https://github.com/ros-industrial/universal_robot/blob/noetic-devel/README.md)
- [ros-industrial/universal_robot on GitHub](https://github.com/ros-industrial/universal_robot)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ros-industrial-universal-robot