RIOT supports most low-power IoT devices and microcontroller architectures (32-bit, 16-bit, 8-bit). RIOT aims to implement all relevant open standards supporting an Internet
of Things that is connected, secure, durable & privacy-friendly.
Three good reasons to think about a new OS for the IoT.
RIOT is Developer Friendly
Program like you are used to. Do not waste time with
complex or new environments.
Standard programming in C or C++
Standard tools such as gcc, gdb, valgrind
Minimized hardware dependent code
Zero learning curve for embedded programming
Code once, run on 8-bit platforms (e.g. Arduino Mega 2560), 16-bit platforms (e.g. MSP430), and on 32-bit platforms (e.g. ARM)
Partial POSIX compliance. Towards full POSIX compliance.
Develop under Linux or Mac OS using the native port, deploy on embedded device
RIOT is Resource Friendly
Benefit from a microkernel architecture and a tickless scheduler on very lightweight devices.
Robustness & code-footprint flexibility
Enabling maximum energy-efficiency
Real-time capability due to ultra-low interrupt latency (~50 clock cycles) and priority-based scheduling
Multi-threading with ultra-low threading overhead (<25 bytes per thread)
RIOT is IoT Friendly
Make your applications ready for the smaller things in the Internet with common system support.
6LoWPAN, IPv6, RPL, and UDP
CoAP and CBOR
Static and dynamic memory allocation
High resolution and long-term timers
Tools and utilities (System shell, SHA-256, Bloom filters, ...)
Comparison of Current Operating Systems
MCU w/o MMU
Development and deployment with open tools and common platforms.
You find all the information you need to get started on the GitHub wiki. For a quick high-level overview, check this introduction to RIOT. For a first hands-on experience, you can try a tutorial. You might also find answers to your questions in the FAQ.
For those of you who are more familiar with non-embedded programming, you should start with the native port of RIOT. This allows to run RIOT inside a process on Linux or Mac OS.
It eases the development and debugging of both, RIOT and projects written for RIOT.
Such a native process can be analyzed using readily available tools such as gdb or valgrind.
You can create virtual testbeds of multiple instances of RIOT running simultaneously and networked together, via a configurable topology. All you need is your PC and Linux or Mac OS!
The RIOT API itself can be built from the code using doxygen. The latest version is uploaded daily to http://riot-os.org/api.
Everything in a box. RIOT supports Docker and Vagrant. Setup your RIOT development environment very easily. We provide a Docker repository, as well as a Vagrant image.
Out of the box usage in industry,
research, and private environments.
RIOT runs on several platforms including embedded devices as well
as common PCs. It supports multiple drivers, which allows you to start out of
the box. The hardware dependent code is reduced to a minimum and abstracted
from the kernel itself.
RIOT is free software: you can redistribute it and/or
modify. Software developed by the RIOT community is available under the
terms of the GNU Lesser General Public License as published by the Free
Software Foundation, version 2.1 (LGPLv2.1).
In short, LGPLv2 allows you to redistribute, use and/or modify the free
open source code developed and maintained by the RIOT community, without
requiring you to necessarily open your code. Other software released under
LGPLv2 include for example VLC, GNU C Library, or Git, as well as software
for industrial products, such as Panasonic LCD HDTV software. Do you need more arguments?
Please read our FAQ.
Through this license, RIOT use is suitable for virtually all scenarios.
But if you think your use case is not covered, contact us
and we will work something out.
Some external libraries (for example
are published under a separate license.
But don't worry, all code files contain licensing information
that provide the necessary details.
You can find our coding conventions and a template for the LICENSE
preamble in the wiki.
You are using RIOT in a scientific context? Please consider one of the following references for citation.
Emmanuel Baccelli, Oliver Hahm, Mesut Günes, Matthias
Wählisch, Thomas C. Schmidt, "RIOT OS: Towards an OS for
the Internet of Things," in Proceedings of the 32nd IEEE
International Conference on Computer Communications (INFOCOM),
Poster Session, April 2013.
Continuous development and progress.
Project roots. The seed for RIOT was FeuerWare, an operating system for Wireless Sensor Networks.
It was part of the FeuerWhere project where firefighters should be
monitored. Major design goals were reliability and real-time guarantees.
Towards Internet compliance. To increase modularity and include new IETF
protocols, µkleos was forked from the orignal
FeuerWare repository. Support for 6LoWPAN, RPL, and TCP was integrated over the
RIOT goes public. RIOT is the direct successor of µkleos. We decided on
re-branding to avoid problems with spelling and pronouncing the
name of the operating system. We explicitly promote RIOT to a larger community.
We have a vision. Be part of the community and follow ongoing enhancements
in our issue
tracker. Start working on new features or let the RIOT community know what you miss!
Emmanuel Baccelli, Oliver Hahm, Mesut Günes, Matthias
Wählisch, Thomas C. Schmidt, "RIOT OS: Towards an OS for the
Internet of Things," in Proceedings of the 32nd IEEE International
Conference on Computer Communications (INFOCOM), Poster Session, April
To the original authors of FeuerWare, the members of the research
projects AVS Extrem, G-Mesh-Lab, OPNEX, SAFEST and VIVE, and anybody
else who has contributed to FeuerWare, µkleos, and RIOT.
Furthermore, a special thank goes to Peter Schmerzl!
Many people are working on RIOT. Public development questions should
be directed to the RIOT-devel mailing list.
If you require one-to-one communication for other development
questions, you can contact the RIOT maintainers, and for
questions related to formal project establishment or
collaboration, you can contact Emmanuel Baccelli, Thomas Schmidt, and