Develop your IoT product �with Renode™


Renode in short

  • Open-source, software-agnostic hardware simulator
  • Provides plug-and-play building blocks to create �custom virtual hardware setups
  • Full determinism of execution, shared virtual time
  • Extensive debugging, tracing, analysis features
  • Made for automated tests and CI integration, inter-team company-wide collaboration


What you can do with Renode

Continuous Integration, testing

TinyML development

Architectural exploration, pre-silicon development

IoT development, operating systems porting

Network protocols implementation and validation

Security analysis


Renode’s strengths

  • Full determinism of execution, shared virtual time
  • Transparent & robust debugging, tracing, analysis, �even in complex setups
  • Easy integration with your everyday tools, plugins
  • Rich model abstractions with additional functionality �‘for free’ + modular platform description format
  • Automated tests and CI integrations, other �collaboration features


Plug-and-play building blocks

  • Create custom hardware setups with reusable blocks
  • Freely combine CPUs, SoC inputs/outputs and peripherals
  • Create complex, multi-node, heterogeneous systems
  • Explore architecture variations just by changing configuration


Peripherals & sensors

Our focus is not just on cores, but also SoC peripherals


As well as sensors:

  • Thermometers, humidity meters, accelerometers, microphones, cameras etc.

This allows things like simulating multi-node robotics systems, end-to-end machine learning processing in simulation with real and synthetic data - with the same binaries as you would run �on hardware.


Simulate complex systems, including multi-node


Notable Renode users



Supported architectures

  • Renode supports a broad range of the most �popular architectures
  • Simulation of both low-power MCUs and multicore, �64-bit application platforms
  • Configurable instruction sets, custom instructions support
  • Support for full hardware platforms, with a broad portfolio �of available boards


Software agnostic - run whatever you want


Supported IDE

  • Renode modular design allows you to easily �integrate with various development environments
  • Integrate via GDB or a custom solution
  • Support various debugging features
  • Have Renode integrated with your current �workflow by Antmicro


Debugging and tracing

01 / 07


Debugging with GDB

  • Renode allows you to debug applications �running on emulated machines using GDB
  • Uses the GDB remote protocol
  • Breakpoints, watchpoints, stepping, �memory access etc
  • Virtual time does not progress when �the emulated CPU is halted
  • Read more on multicore debugging in Renode


Execution and event tracing

  • Renode gives you full inspection in the behavior of your software
  • Easily log executed functions or peripheral accesses
    • Filter the interesting data or see the full log
  • Robust event tracing mechanisms:
    • Peripheral accesses / watchpoints
    • Network packets
    • UART output
    • Executed code blocks
    • Interrupts
    • Synchronization points
    • Implement event handlers in runtime, in C# or Python


Online disassembly

  • Renode uses LLVM backend for disassembly
  • Analyze code in runtime
  • Precisely trace failing code without manual debugging
  • Support for all available architectures, including different RISC-V instruction sets


IN: log_core_init (address: 0x80002e30)

0x80002e30: 800037b7 lui a5, 524291

0x80002e34: 000a1537 lui a0, 161

0x80002e38: d9078793 addi a5, a5, -624

0x80002e3c: 80040737 lui a4, 524352

0x80002e40: 22050513 addi a0, a0, 544

0x80002e44: 0af72423 sw a5, 168(a4)

0x80002e48: 5c0010ef jal 5568



  • Extensive and customisable logging capabilities
  • Precise filtering depending on the log source �and target: console or log file
  • Built-in graphical log analyser
  • Various sources of data
    • Executed software
    • Peripherals analysis
    • Framework events
    • User-defined events



02 / 07


Internal scripting language

  • Renode allows you to interact with every detail �of the emulation via its CLI - the Monitor
  • Monitor commands can be run as scripts
  • Create the emulation, load software
  • Access all peripherals and settings
  • Control the emulation and tracing options
  • Add your own commands on the fly

using sysbus

mach create $name

machine LoadPlatformDescription


emulation CreateSwitch "switch"

connector Connect ethmac switch

emulation CreateNetworkServer "server"


connector Connect server switch

server StartTFTP 6069

server.tftp ServeFile $micropython


showAnalyzer uart

macro reset


sysbus LoadBinary $bios 0x0

cpu PC 0x0


runMacro $reset


Python support

  • Renode enables use of IronPython
  • Complex event hooks with flow control
  • Access to emulation detail
  • Hook on:
    • Blocks of code
    • PC value, watchpoints
    • Interrupts
    • Memory/peripheral access
    • Network packets
    • Serial data
    • Whatever you want

(machine) include

(machine) set py_notification_hook

> """

> # recipient and get_recipients defined in external file

> for recipient not get_recipients():

> recipient.send_notification(self.line)

> """

(machine) uart AddLineHook "interesting value" $py_notification_hook

(machine) cpu AddHookAtInterruptBegin

"self.DebugLog('exception %d' % exceptionIndex)"


Text-based platform descriptions

  • Renode assembles platforms from building blocks
  • .repl format - Renode platform description file
  • Changing details of the platform is as easy �as editing a text file
  • Great for prototyping
  • Enables easy support for lines of similar products
  • Can be easily auto-generated - ideal for �soft SoC support

nvic: IRQControllers.NVIC @ sysbus 0xE000E000

-> cpu@0

cpu: CPU.CortexM @ sysbus

cpuType: "cortex-m4"

nvic: nvic

spi2: SPI.NRF52840_SPI @ sysbus 0x40023000

-> nvic@0x23

gpio0: GPIOPort.NRF52840_GPIO @ sysbus 0x50000000

gpiote: GPIOPort.NRF52840_GPIOTasksEvents @ sysbus 0x40006000

port0: gpio0

-> nvic@6

uart0: UART.NRF52840_UART @ sysbus 0x40002000

easyDMA: true

-> nvic@2


Easy prototyping with model stubs

  • Renode embraces needs-based, �iterative platform development
  • Model parts that you really need
  • Log or mock everything else
  • Implement Python peripherals �as one liners or in separate files

rcc: Python.PythonPeripheral @ sysbus 0x40023800

size: 0x400

initable: true

script: “0xFFFFFFFF if request.offset != 0x8 else 0xFFFFFFFA”

pwrCr1: Python.PythonPeripheral @ sysbus 0x40007000

size: 0x4

initable: true

filename: "scripts/pydev/"


HW descriptions with SVD support

  • Can tag known bus addresses with default read values
  • For platforms supporting those (mainly Cortex-M). can load SVD files and read those automatically



Tag <0x400E0940 0x4> "CIDR" 0xa1020e00

ApplySVD @ATSAME70Q21.svd


CI and testing

03 / 07


Renode-based Continuous Integration workflow for IoT systems


CI integrations

  • GitHub Actions
  • ResultsStore support
  • BuildBuddy
  • Twister in Zephyr
  • Can be used with Gitlab CI, Travis, Jenkins, etc
  • Integration via:
    • Robot Framework
    • Python API
    • Renode’s headless mode
    • ...


Robot Framework

  • Robot interface for writing tests either in Python or “natural” language
  • Renode provides keywords enabling various testing scenarios
  • Whole Renode CLI is also exposed
  • Readable reports and artifacts after each run

Should Print To Uart

Setup Machine

Start Emulation

Wait For Line On Uart The LEDs show the ASCII code of the last character.

Provides initialization

Should Echo On Uart

Requires initialization

Write Line To Uart Testing testing 1-2-3

Provides working-uart


Execution metrics

  • Gather metrics in a CI run
  • Do post-mortem analysis, comparing with previous results
  • Detect performance anomalies early during development
  • Currently supported:
    • Executed instructions,
    • Memory access
    • Peripheral access
    • Exceptions

Renode emulation



Matplotlib backend

PNG files

Metrics Analyzer





Events recording

  • Record external events
    • Key presses
    • Network packets
    • GPIO changes
  • Replay them to get the same, deterministic execution �with user input
  • Isolate a failing node by not simulating the whole network
  • Share recording with your team to trace down bugs


State saving

  • Renode allows you to save the state of the whole emulation
  • Creates one file that is enough to load the setup
  • Share it with your team to solve problems together
  • Create artifacts from CI to analyze failed test cases


Determinism of execution

  • Simulation in Renode behaves the same way �regardless of the host machine performance
  • All events are happening in virtual time
  • Allows you to get same results on a CI and locally
  • Key feature to create reliable tests
  • Reproducibility even with inter-machine communication
  • Limited when interfacing with external world
    • Can obtain full reproducibility with events recording


HW/SW co-development

04 / 07


Co-simulation with HDL simulator

  • Provides an integration layer for Verilator
  • Enables HW/SW co-simulation with Verilator
  • No need to create models of the IP you can “verilate”
  • Supports AXI4Lite and Wishbone, full AXI4 under way
  • Support for interrupts and external interfaces, �like UART Rx/Tx lines


Co-simulation with HDL simulator


Co-simulation with Hardware via Etherbone bridge

  • Another alternative that can be used in FPGA co-development is emulating IP on real FPGA HW
  • Majority of simulation (e.g. RISC-V SoC) �is in Renode, only the part under development �is in the FPGA
  • Renode supports EtherBone protocol, �to interact with Wishbone-connected soft IP
  • Connection with the FPGA over a socket - possibly �in a remote location


Co-simulation with Hardware via Etherbone bridge


Networking and multi-node


05 / 07



  • Renode allows you to simulate multiple nodes at once
  • Nodes can be connected via various means:
    • Ethernet
    • Wireless connection
    • UART
    • CAN
    • GPIO
    • USB
    • ...


Wired networking

  • Allows to connect nodes in a switchable network
  • Protocol-independent
  • Support for built-in servers
    • Modular, extendible framework
    • Support for TFTP, more to come
  • Host network integration via TAP interface
    • Allows you to connect your usual network tools �to the simulated environment
  • Support for Time-Sensitive Networking



  • Abstract, packet based communication - works with �all types of wireless networks
  • Protocol-independent
  • Support for node positioning
  • Ability to select delivery function
    • Always deliver
    • Maximum range
    • Stochastic delivery
    • User-defined logic


Network bridging

  • Allows defining physically separated networks for multi-band scenarios
  • Independent delivery functions for all networks
  • Showcased by support for TI dual radio Zolertia Firefly


Wireshark support

  • You can inspect network traffic in Wireshark, �both wired and wireless
  • Support for Linux, Windows and macOS
  • Flexible configuration
    • Hardware-less CI-driven workflows for IoT
    • Observe all traffic
    • Watch specific interfaces
  • No need to connect to the host network


Host/guest integration

  • Renode allows you to use your everyday tools �like you would use them with real hardware
  • Multiple integration options:
    • Ethernet via TAP interface
    • UART via PTY device
    • UART via sockets
    • USB via USB/IP protocol


Selected case studies

06 / 07


TensorFlow Lite Micro

  • Collaboration since 2018
  • Many collaborative projects, including a rework of TensorFlow Lite micro’s CI using Renode:
    • Hardware-less CI-driven workflows for IoT
    • Testing full flow including sensors fed with real data
    • Tests based on the binaries used on hardware
  • Implemented Arduino CLI/IDE support for upcoming education courses by Google and Harvard
  • Many jointly developed samples in example repo, with Google Colab in-browser versions
  • Read more article on TF Lite blog demoing usage of TensorFlow Lite in Renode and physical board



  • Renode support for EOS S3 - first FPGA-enabled SoC supported in open source FPGA tooling (also developed by Antmicro)
  • Comprehensive project by Antmicro also including Zephyr RTOS, FPGA IP and hardware
  • Showcased Renode’s co-simulation capability


Next step: RISC-V + open source FPGA

  • Next gen platform with RISC-V and larger FPGA
  • Also supported in open source FPGA tools �developed by Antmicro
  • Part of Open Hardware Group’s Core-V project, collaboration with e.g. NXP and Silicon Labs
  • Will enable high-perf, low-power TinyML
  • Renode support co-sponsored by Google and QuickLogic
  • Read more


Microchip PFSoC

  • Renode support for Microchip’s PolarFire FPGA SoC �and Mi-V RISC-V-based soft CPUs
  • Support for Icicle Kit - first development platform �for PolarFire SoC
  • Delivered to Microchip’s customers before �silicon availability
  • Renode integrated with the SoftConsole software development environment
  • Result: a test-driven software development methodology for all Mi-V and PFSoC users



  • FPGA-based development platform for security �critical applications - authenticators, crypto wallets �and secure messaging
  • Renode was used to simulate technology stack �including Xous (Rust-based OS)
  • The project continues to use Renode for emulating additional hardware
  • Read more


Dover Microsystems

  • Dover is developing CoreGuard™ cybersecurity silicon IP, recently endorsed by NXP
  • Renode leveraged both for Dover’s internal development as well as a demonstration and evaluation platform for their customers
  • Renode extended by Antmicro for Dover with more fine-grained control over execution and debugging
  • Perfect example of how Renode can be used �in hardware/software co-design for security
  • Read more


Zephyr Project

  • Antmicro is a member of the Zephyr Project
  • Common goals with Renode: building scalable, �secure and well-architected IoT systems
  • Joint marketing, development and demos
  • Renode is a one of the recommended Zephyr development tools and part of Zephyr’s CI system
  • Allows users to simulate complex wireless �(and wired) setups running real binaries for testing, �CI and debugging



  • Very Efficient Deep Learning in IoT - EC-funded edge ML oriented project, coordinated by Bielefeld University, �12 international members
  • Scalable, deep-learning capable ML pipelines, between CPU/GPU/FPGA
  • Renode used as a simulation platform, enabling development and CI testing of VEDLIoT's security features and its robustness
  • Read more in our introductory blog note


Renode in education

  • Great platform for experimentation, research and education purposes
  • Tracing and debugging features allow students �to analyze and get a good understanding of the development process
  • Renode to be used in Harvard University’s edX course with over 16000 participants
  • PUT course in collaboration with ST - make TinyML boards available to students virtually during pandemic despite lab closures
  • Many other universities adopting Renode for embedded hardware and software education


Get Started

07 / 07


Packages for all major OS’s

Download the latest release from GitHub

  • Multiple Linux distros �(.deb, .rpm, .pkg.tar.xz, .dmg)
  • Windows
  • macOS


Renode Portable for Linux

  • Standalone version of Renode, all dependencies included
  • Download latest release as one file
  • Read more


Other methods

  • Docker imagedocker pull antmicro/renode
  • Conda packageconda install -c antmicro renode
  • Building from source


Renode in Google Colab

  • Colab is a (mostly) Python workspace in the cloud based �on Jupyter notebooks
  • Allows you to run arbitrary scripts and share the results online
  • Fantastic tool for presentation purposes
  • Very popular among students and academics
  • Together with Google we implemented colabs which can process video and audio recorded from your computer
  • See TF Lite Micro colab examples


Renode in Google Colab


Use our Renode development services

Setting up CI and improving development workflows �in your organization

Building customized tools, user interfaces �and integrations

Professional support, implementing �new platforms

Embedded systems development services powered by the �RENODE methodology


Reach out to us: