By:

What is Renode™?

Renode is a development framework which accelerates IoT and embedded systems development by letting you simulate physical hardware systems - including both the CPU, peripherals, sensors, environment and wired or wireless medium between nodes.

It lets you run, debug and test unmodified embedded software on your PC - from bare System-on-Chips, through complete devices to multi-node systems.

Swipe Down! Scroll Down! Swipe Scroll

01 / 03

Layer #1:

System-On‑Chip

Renode lets you assemble virtual System-on-Chips from building blocks, including Cortex-M, Cortex-A, RISC-V and other CPUs as well as a variety of communication buses and interfaces.

System-On-Chip

It's all a matter of simple, text-based configuration, so that you don't have to copy-paste code and modify hard-coded values to build the platform you need. The flexibilty or Renode enables e.g. pre-silicon development of hardware-software systems - see the CoreGuard customer case for an example.

02 / 03

Layer #2:

The device

Add LEDs, buttons, sensors, snap on a radio module and you're done! Yes, Renode can also simulate entire devices which means you can run unmodified firmware that you are/will be using in production.

i
i
i
i
i
i
i
Buttons IMU LCD LED Radio module SoC Buttons IMU LCD LED Radio module SoC Buttons IMU LCD LED Radio module SoC
The device

Your virtual boards can include multiple SoCs, sensors and actuators. This lets you transfer to a software-first workflow: write your software using Renode, play around with various hardware configurations and build your physical platform based on real needs.

03 / 03

Layer #3:

Multi-node system

This is where things get even more interesting: connect several virtual boards in one Renode simulation environment using wired or wireless interfaces and test your protocols, system-level security, usage scenarios.

Complex system Complex system Complex system Complex system

Thanks to a unified, deterministic time flow, you can stop and debug the entire system state at the same time, save its state and share with your colleagues in a collaborative environment, and set up Continuous Integration to repeatedly test multi-node setups without the need for creating costly physical testing rigs - and with the freedom to copy, distribute, scale as needed - Renode is all software!

02 / 05

Scenarios & Applications

Renode can alleviate many of the pains in multi-node IoT development and let you improve many aspects of the process:

  • Testing & debugging
  • Development speed
  • Teamwork
  • Reliability and security
  • Inter­operability
The problem:

Thoroughly testing an IoT setup is very difficult, especially at scale. Debugging of one node affects timing constraints in communication with other nodes. Bugs in corner cases are usually detected too late.

The solution:
  • Debug the whole system at once, attaching GDB to any node and seeing the synchronized state of the entire network.

  • Create breakpoints and watchpoints that don’t alter your software’s behavior.

  • Use Continuous Integration (CI) to automatically test each iteration of your software.

  • Simulate different conditions, configuring e.g. the network medium to your needs.

The problem:

Development is often delayed by lack of hardware. Iteration cycles are slow because deployment and testing are error-prone, time consuming and frustrating. Debugging on real hardware is difficult.

The solution:
  • Using emulation, start developing software before hardware is ready.

  • Parallelize development even if you do not have enough boards, work from anywhere.

  • Adjust the emulated platform to your needs, experiment, give feedback to the hardware team.

  • Debug and test with better tools, more control and fewer problems.

The problem:

Reproducible testing in IoT is virtually unattainable: bug hunting efforts are difficult to distribute among developers, and onboarding new team members is hard.

The solution:
  • Save the state of emulation, send it to another developer for analysis.

  • Record events occurring in a complex setup, replay them for an isolated machine for simpler and faster debugging.

  • Easily analyze the state of every peripheral of every node of the system.

  • Strictly control virtual time, preserving deterministic execution regardless of the host machine.

The problem:

Security in IoT is often neglected which can have severe consequences, but it's impractical to verify behavior in different conditions.

The solution:
  • Use standard PC-based tools to test different attack vectors.

  • Configure sensor input, node positions and other environment parameters.

  • Analyze network traffic, inject errors and observe results.

The problem:

Working with heterogeneous systems requires lots of different hardware. Backward compatibility requirements increase the cost and complexity of testing.

The solution:
  • Run different OSes on different nodes to verify your algorithms.

  • Use extensive logging and tracing capabilities to compare implementations.

  • Automatically test many versions of your software to verify compatibility.

03 / 05

Supported platforms

Renode supports a wide range of devices from multiple vendors, and makes it easy to add new ones:

Intel Quark
LEON3
ST
Nvidia Tegra
Microsemi Mi-V
NXP
Risc-V
Silicon Labs
Texas Instruments
ZynQ
SiFive

04 / 05

Integrations with external tools

You can find Renode's documentation at ReadTheDocs:

Readthedocs.io

05 / 05

Cross-platform

Renode™ works on all the popular operating systems.

Linux Windows macOS

Looks like you're using a mobile device. Leave us an e‑mail address and we will remind you to download Renode.

Email must be formatted correctly.
The download links have been sent to your email address.