Reveal the runtime world with Tracealyzer and boost your software development.

Tracealyzer is the premier trace visualization tool for developers of RTOS- or Linux-based embedded software systems. Get amazing insight into the real-time behavior of your software during development, debugging, validation and optimization. Boost your development and deliver robust, responsive software, on time and within budget.

  • See the runtime world of your embedded software with 25+ graphical views.

  • Analyze execution and timing of RTOS tasks and interrupts.

  • See RTOS API calls and application logging.

  • Simplifies debugging, validation, optimization and training.


“Tracealyzer has always offered exceptional value to our global community of users by giving engineers direct insight into how their applications are executing. This information is invaluable when both optimizing and debugging FreeRTOS applications.” – Richard Barry, FreeRTOS founder.


“Percepio Tracealyzer enables unparalleled insight into the execution, timing and interactions of the RTX5 real-time operating system, the MDK middleware components and the user application. Percepio is the first ARM partner to utilize our new Event Recorder technology, which provides time deterministic high-speed access to a running target system.”Reinhard Keil, Director of MCU Tools at ARM.


“We are extremely excited and pleased about the Tracealyzer port to our Industrial Grade ThreadX RTOS. The combined best-in-class visualization assets of Percepio’s Tracealyzer and our industry leading ThreadX RTOS will greatly help embedded developers confidently get their IoT products to market quicker.” – William E. Lamie, President and CEO at Express Logic Inc.

Micrium µC/OS

“What Percepio has achieved with Tracealyzer is to remove the guesswork of designing an RTOS-based system. It’s ability to record and then analyze what’s happening gives developers a view into their system that would be impossible to have otherwise.” – Jean Labrosse, president and CEO at Micrium Inc.

Perhaps you have used some tracing tool before, but this is more than a just another trace viewer. This is state-of-the-art visualization developed since 2004, designed to make traces much easier to understand. The visualization actually understands the meaning of the most RTOS events and performs advanced analyses to improve the visualization by connecting related events and views. This makes it much easier to draw conclusions from the data, understand the problem and verify the solution.

Tracealyzer can be used side-by-side with traditional debuggers, such as IAR, Keil or Eclipse tools, and complements the detailed debugger view with several additional views on system level, ideal for understanding real-time issues where a classic debugger is not sufficient. For instance, in real-time systems such as motor control, it is often not possible to stop the system for debugging. By using software tracing, you can record your embedded software and any variables of interest in real time as the system executes.

Example views

In the above illustration, the top left picture shows the vertical trace view including task scheduling, interrupt handlers (ISRs) and other software events. The top right shows a horizontal task/ISR trace combined with message queue lengths. The lower left shows a plot of logged application data, while the lower right shows the CPU load over time.

Over 25 such views of the run-time behavior are provided, including task scheduling and interrupt handler/ISR execution, task timing (execution time and other metrics), task priority, CPU load, memory usage, as well as interactions between tasks and interrupt handlers/ISRs via e.g., message queue, semaphore and mutex objects. This way, you can see if your task priorities, execution times and timeouts are suitable, to avoid timeout errors from task preemption or blocking. For example, perhaps the USB task must be allowed to preempt the TCP/IP task, to reduce its response time and avoid a semaphore timeout? Perhaps some mutex is used by many tasks, and thereby frequently block the execution and cause delays?

You can also do custom logging of “User Events” from your application code to see states and variables over time, in parallel with the other views. This can be used to analyze and debug the real-time behavior of your algorithms, such as motor control loops. Both the software logic itself, and its performance. For instance, how much execution time is needed? Can I run my control loop at a higher rate? Is the task timing steady?

The profiling views allows you to see what parts of the system that uses most resources (e.g. processor time and heap memory). Perhaps some part is using much more CPU cycles than motivated, due to inefficient code? The memory usage views also allow you to locate possible memory leaks. You can filter out all “malloc” events that have matching “free” events using the “Show remaining only” option, showing all events that could be a memory leak.

All views are interconnected in clever ways, so you can click on a data point in one view and see the corresponding location in another related view. Moreover, all timeline views can be synchronized, so you can scroll and zoom them side-by-side. This way, you can benefit from multiple perspectives at the same time and better understand the trace.

The trace can be streamed in real-time, either using a supported debug probe or by using a custom target-host interface, such as a USB or TCP/IP. So far, this is supported for FreeRTOS, Micrium and SafeRTOS, but additional streaming support is planned.

No special trace hardware is required, as Tracealyzer relies on efficient software instrumentation with minimal overhead. This way, it works on essentially any processor or microcontroller, assuming you have a few kilobytes available for the trace recorder module. It is designed for 32-bit target processors and upwards, including ARM Cortex-M MCUs such as STMicroelectronics STM32, NXP LPC and Kinetis series, Renesas Synergy, Silicon labs EFM32, Cypress PSoC, Atmel SAM, TI MSP432, TI TMC4 and Infineon XMC4. We also support Renesas RX, Renesas RZ, Microchip PIC32, Atmel AVR32, ARM Cortex-R, ARM Cortex-A, Xilinx Zynq, Xilinx Microblaze, Altera Nios II and Synopsys ARC processors. And even if your processor family is not yet directly supported, you can easily develop your own port. You just need to define a few macros, mainly for reading the current time.

You can even use it in deployed systems, to get traces from sporadic errors that are otherwise very hard to reproduce. We have customers that ship their products with tracing enabled. By saving the latest trace on any detected error, they get valuable information on problems in deployed customer operation.

Several leading IDEs are explicitly supported, such as IAR Embedded Workbench, Keil µVision (MDK), Atmel Studio, Microchip MPLAB X IDE, Wind River Workbench, and most Eclipse-based IDEs (e.g. Atollic TrueStudio, SW4STM32, Code Composer Studio (TI CCS), NXP LPCxpresso/MCUxpresso etc.).

Tracealyzer can be used with any IDE, as long as you can save RAM contents to a host-side file (.bin or .hex) or have a target-host interface available for streaming the trace data to host. Note that the Keil RTX5 version however requires Keil µVision (Keil MDK) version 5.23 or newer for the data access.

Unlike some other trace tools, multiple RTOS and Linux platforms are supported, including FreeRTOS, Amazon FreeRTOS (a:FreeRTOS), SafeRTOS, Micrium µC/OS, ThreadX, Keil RTX5 and VxWorks. So if you later decide to change platform, there is a good chance you can keep using Tracealyzer.

Sounds good?

Download now and try the included demo trace to explore the broad range of visualizations.

To learn more about practical use of software tracing, check out the Getting Started page with videos and example cases.

Read our white paper to learn more about embedded software tracing in general.