Urbi SDK is a fully-featured environment to orchestrate complex organizations of components. It is an
open source framework for complex systems. It relies on a middleware architecture that coordinates
components named UObjects. It also features urbiscript, a scripting language tailored to write
Urbi makes the orchestration of independent and concurrent components easier. It was ﬁrst designed
for robotics: it provides all the needed features to coordinate the execution of various components
(actuators, sensors, software devices that provide features such as text-to-speech, face recognition and
so forth). Languages such as C++ are well suited to program the local, low-level, handling of these
hardware or software devices; indeed one needs eﬃciency, small memory footprint, and
access to low-level hardware details. Yet, when it comes to component orchestration and
coordination, in a word, when it comes to addressing concurrency, it can be tedious to use such
Middleware infrastructures make possible to use remote components as if they were local, to allow
concurrent execution, to make synchronous or asynchronous requests and so forth. The
UObject C++ architecture provides exactly this: a common API that allows conforming
components to be used seamlessly in highly concurrent settings. Components need not be
designed with UObjects in mind, rather, UObjects are typically “shells” around “regular”
Components with an UObject interface are naturally supported by the urbiscript programming
language. This provides a tremendous help: one can interact with these components (making queries,
changing them, observing their state, monitoring various kinds of events and so forth), which provides
a huge speed-up during development.
Although made with robots in mind, the UObject architecture is well suited to tame any heavily
concurrent environment, such as video games or complex systems in general.
The Section 1.1 shows the architecture of Urbi. Let’s browse it bottom up.
Figure 1.1: A Bird-View of the Urbi Architecture
At the lowest level, Urbi requires a (possibly very limited) embedded computer. This is the case for
most robots today, but on occasion, some device cannot even run reasonably small pieces of code. In
that case, Urbi can still be used, but then the robot is actually remote-controlled from a computer
Right on top of the hardware, is running the Operating System. Urbi supports the major OSes; it
was also ported on top of real-time OSes such as Xenomai, and on speciﬁc OSes such as Aperios,
Sony’s proprietary system running its Aibo robotic dog.
The Urbi Runtime, which is the actual core of the system, also known as the engine or the kernel,
is interfacing the OS with the rest of the Urbi world, urbiscript and UObjects.
UObjects are used to bind hardware or software components, such as actuators and sensors on the
one hand, and voice synthesis or face recognition on the other hand. They can be run locally on the
robot, or on a remote, more powerful, computer.
To orchestrate all the components, urbiscript is a programming language of choice (see
urbiscript is a programming language primarily designed to handle concurrent programming. It’s a
dynamic, prototype-based, object-oriented scripting language. It supports and emphasizes parallel and
event-based programming, which are very popular paradigms in robotics, by providing core primitives
and language constructs.
Its main features are:
- syntactically close to C++.
- fully integrated with C++.
You can bind C++ classes in urbiscript seamlessly. urbiscript is also integrated with many
other languages such as Java, MatLab or Python.
It supports encapsulation, inheritance and inclusion polymorphism. Dynamic dispatching
is available through monomethods — just as C++, C# or Java.
It provides you with natural constructs to run and control high numbers of interacting
Triggering events and reacting to them is absolutely straightforward.
- functional programming.
Inspired by languages such as Lisp or Caml, urbiscript features ﬁrst class functions and
The interpreter accepts multiple connections from diﬀerent sources (human users, robots,
other servers …) and enables them to interact.
You can run objects in diﬀerent processes, potentially remote computers across the
Urbi what ﬁrst designed and implemented by Jean-Christophe Baillie, together with Matthieu Nottale.
Because its users wildly acclaimed it, Jean-Christophe founded Gostai, a France-based Company that
develops software for robotics with a strong emphasis on personal robotics. Gostai has been acquired
by Aldebaran Robotics in 2012. Urbi is now a community-driven open source project available at
Urbi SDK 1 was further developed by Akim Demaille, Guillaume Deslandes, Quentin Hocquet, and
The Urbi SDK 2 project was started and developed by Akim Demaille, Quentin Hocquet, Matthieu
Nottale, and Benoît Sigoure. Samuel Tardieu provided an immense help during the year 2008, in
particular for the concurrency and event support.
The maintenance in Gostai was carried out by Akim Demaille, Quentin Hocquet, and Matthieu
Nottale. Jean-Christophe Baillie is still deeply involved in the development of urbiscript, he regularly
submits ideas, and occasionally even code!
Many people contributed signiﬁcantly to Urbi, including Alexandre Morgand, Romain Bezut,
Thomas Moulard, Clément Moussu, Nicolas Pierron.
This multi-part document provides a complete guide to Urbi. See Listing 28 for the various notations
that are used in the document.
Listing IV — Urbi and UObjects User Manual
This part covers the Urbi architecture: its core components (client/server architecture), how its
middleware works, how to include extensions as UObjects (C++ components) and so
No knowledge of the urbiscript language is needed. As a matter of fact, Urbi can be
used as a standalone middleware architecture to orchestrate the execution of existing
Yet urbiscript is a feature that “comes for free”: it is easy using it to experiment, prototype, and
even program fully-featured applications that orchestrate native components. The interested
reader should read either the urbiscript user manual (Listing I), or the reference manual
Listing I — urbiscript User Manual
Listing 24 — Quick Start
This chapter, self-contained, shows the potential of Urbi used as a middleware.
Section 25 — The UObject API
This section shows the various steps of writing an Urbi C++ component using the
Listing 26 — The UObject Java API
UObjects can also be written in Java. This section demonstrates it all.
Section 27 — Use Cases
Interfacing a servomotor device as an example of how to use the UObject architecture
as a middleware.
This part, also known as the “urbiscript tutorial”, teaches the reader how to program in
urbiscript. It goes from the basis to concurrent and event-based programming. No speciﬁc
knowledge is expected. There is no need for a C++ compiler, as UObject will not be covered here
(see Listing IV). The reference manual contains a terse and complete deﬁnition of the Urbi
environment (Section III).
paragraph II — Guidelines and Cook Books
Listing 3 — First Steps
First contacts with urbiscript.
Section 4 — Basic Objects, Value Model
A quick introduction to objects and values.
Section 5 — Flow Control Constructs
Basic control ﬂow: if, for and the like.
Listing 6 — Advanced Functions and Scoping
Details about functions, scopes, and lexical closures.
Listing 7 — Objective Programming, urbiscript Object Model
A more in-depth introduction to object-oriented programming in urbiscript.
Listing 9 — Functional Programming
Functions are ﬁrst-class citizens.
Listing 10 — Parallelism, Concurrent Flow Control
The urbiscript operators for concurrency, tags.
Listing 11 — Event-based Programming
Support for event-driven concurrency in urbiscript.
Listing 12 — Urbi for ROS Users
How to use ROS from Urbi, and vice-versa.
This part contains guides to some speciﬁc aspects of Urbi SDK.
Section III — Urbi SDK Reference Manual
paragraph 13 — Installation
Complete instructions on how to install Urbi SDK binary packages.
paragraph 14 — Frequently Asked Questions
Some answers to common questions.
Section 15 — Urbi Guideline
Based on our own experience, and code that users have submitted to us, we suggest
a programming guideline for Urbi SDK.
Listing 16 — Migration from urbiscript 1 to urbiscript 2
This chapter is intended to people who want to migrate programs in urbiscript 1 to
Listing 18 — Building Urbi SDK
Building Urbi SDK from the sources. How to install it, how to check it and so forth.
This chapter is meant only for people who want to build Urbi SDK, which is orders
of magnitude more delicate than simply installing the binary packages from Gostai.
This part deﬁnes the speciﬁcations of the urbiscript language. It deﬁnes the expected behavior
from the urbiscript interpreter, the standard library, and the SDK. It can be used to check
whether some code is valid, or browse urbiscript or C++ API for a desired feature. Random
reading can also provide you with advanced knowledge or subtleties about some urbiscript
This part is not an urbiscript tutorial; it is not structured in a progressive manner and is too
detailed. Think of it as a dictionary: one does not learn a foreign language by reading a
dictionary. For an urbiscript Tutorial, see Listing I.
This part does not aim at giving advanced programming techniques. Its only goal is to deﬁne the
language and its libraries.
Listing V — Tables and Indexes
Section 19 — Programs
Presentation and usage of the diﬀerent tools available with the Urbi framework related
to urbiscript, such as the Urbi server, the command line client, umake, …
Section 20 — urbiscript Language Reference Manual
Core constructs of the language and their semantics.
Listing 21 — urbiscript Standard Library
The classes and methods provided in the standard library.
Section 22 — Communication with ROS
Urbi provides a set of tools to communicate with ROS (Robot Operating System).
For more information about ROS, see http://www.ros.org.
Section 23 — Urbi Standard Robotics API
Also known as “The Urbi Naming Standard”: naming conventions in for standard
hardware/software devices and components implemented as UObject and the
corresponding slots/events to access them.
This part contains material about the document itself.
Listing 28 — Notations
Conventions used in the type-setting of this document.
Listing 29 — Grammar
Grammar of the urbiscript language.
Section 31 — Licenses
Licenses of components used in Urbi SDK.
Listing 30 — Release Notes
Also known as the Urbi ChangeLog, or Urbi NEWS, this chapter lists the user-visible
changes in Urbi SDK releases.
Section 32 — ł::bel sec:bibliographyBibliography
References to other documents such as documentation, scientiﬁc papers, etc.
Section 33 — Glossary
Deﬁnition of the terms used in this document.
Section 34 — List of Tables
Index of all the tables: list of keywords, operators, etc.
Section 35 — List of Figures
Index of all the ﬁgures: snapshots, schema, etc.