Percepio Tracealyzer®
The Embedded Software Development Tool for Visual Observability
Visual trace observability for “X-ray vision” in your embedded software development.
Speed up everyday debugging, solve issues and deliver great products on time.
Simplify Debugging and Develop Faster
“Tracealyzer has doubled our development speed. Problems that would take days to solve are obvious with this tool and just a quick fix. We use it all the time.” — Alex Pabouctisids, Lead Firmware Engineer, Flyability
Fed up with endless hours debugging embedded C/C++ code? Bid farewell to tedious troubleshooting and welcome accelerated development with Percepio Tracealyzer. Traditional debugging is often ineffective for today's complex RTOS or Linux systems and may consume 40-50% of the development time.
Tracealyzer gives you visual trace observability to:
- Identify bugs faster – see the sequence of events leading to a crash or fault
- Solve timing-sensitive issues that disappear the moment a breakpoint is set
- Cut debugging time and deliver products on schedule
Optimize System Performance
“In less than 5 days from running the tool, we improved the performance of our graphic rendering engine by 3x” — Terry West, CEO, Serious Integrated, Inc.
Tracealyzer’s advanced profiling features show the events behind the numbers:
- CPU load graphs – see which tasks consume the most cycles
- Stack and heap memory usage – track allocation patterns over time
- Timing plots – pinpoint where execution time is spent
- Event-level detail – go from the graph to the exact kernel event that caused the bottleneck
Pinpoint performance bottlenecks, unlock the full potential of your hardware, and ensure you meet product performance goals.
Watch the Brief Introduction (2 min)
See our 2-minute video on how Tracealyzer works.
How it Works – From Events to Insight
Tracealyzer visualizes the behavior and timing of embedded software using a lightweight tracing library added to the target system. It extends your RTOS kernel via preexisting hooks, no intrusive changes to application code.
What gets captured:
- Task switches and scheduling events
- Kernel API calls (semaphores, queues, mutexes)
- Blocking events and timeouts
- CPU load, stack and heap usage
- Custom user events via a simple C API – log variable values, application state, or any debug event you define
How you explore it:
- Visual graphical views for debugging, profiling and anomaly detection
- Use continuous live streaming for real-time insight
- Capture in-memory snapshots to study the critical moments leading up to a problem
Tracealyzer is a 100% software solution, no trace port is required on your device. It works with the debug probe you already have, and can use fast probes such as IAR I-Jet and Segger J-Link for high-speed continuous streaming.
User Testimonals
Bare-metal, RTOS and Linux
Tracealyzer provides prepackaged support for many popular embedded operating systems and RTOS kernels:
- FreeRTOS
- Zephyr
- Eclipse ThreadX
- PX5 RTOS
- SafeRTOS
- LynxOS-178
- VxWorks
- Linux (embedded)
The Tracealyzer SDK enables other OS integrations and extensions for full-stack observability. The Bare-Metal option works in any C/C++ project, with or without a supported RTOS kernel.
On any processor
Tracealyzer supports many processor families, including STM32, NXP i.MX RT, Xilinx Zynq and other Arm devices, ESP32 and others. Tracealyzer is commonly used on 32-bit microcontrollers, 64-bit multicore SoCs, and everything in between.
Compatible with All Embedded Software Development Tools
Tracealyzer can be used with any compiler, including GCC, Clang and IAR Embedded Workbench. Specific guides and debugger support are available for Arm Keil µVision, IAR, Segger J-Link, STM32CubeIDE, Espressif ESP-IDF, and Lauterbach.
The Five Layers of an Embedded Software Development Toolchain
A complete embedded development toolchain typically spans five layers. Most teams have four covered from day one – the fifth is where Tracealyzer comes in.
- Compilers and build systems
Cross-compilers translate your C or C++ source into machine instructions for the target architecture. Common choices include GCC (ARM, RISC-V), Clang/LLVM, and IAR Embedded Workbench. Build systems such as CMake and Make automate compilation and linking. - IDEs
Integrated development environments combine editor, compiler, and project management in a single workspace. Widely used IDEs in embedded development include Keil µVision, STM32CubeIDE, SEGGER Embedded Studio, MPLAB X and Eclipse-based environments. They handle code editing, syntax checking, and basic debugging. - Debug probes and hardware interfaces
Hardware debug probes – SEGGER J-Link, IAR I-Jet, Lauterbach TRACE32 – connect your development machine to the target microcontroller for step-through debugging and flash programming. They are the standard interface for stopping and inspecting a running system. - RTOS and middleware
For multi-threaded systems, an RTOS manages task scheduling, synchronization, and resource allocation. FreeRTOS, Zephyr, Eclipse ThreadX, and VxWorks are common choices, each with different licensing, safety certification, and memory footprint profiles. - Observability and tracing, where Tracealyzer fits
A debugger halts the processor. The four tool layers above tell you the state of the system when you stop it. Tracealyzer tells you how it got there. A continuous, timestamped record of every task switch, semaphore or queue operation, timeout, and custom user event, captured while the system runs at full speed.
For timing-sensitive faults, intermittent crashes, priority inversions, and CPU load issues that disappear the moment your system hits a breakpoint, a tracer is not optional, it is the only tool that sees what actually happened. Flyability reports doubling their development speed by adding Tracealyzer to a toolchain that already had the other four layers in place.
Learn More
There are plenty of articles and customer cases in our blog and Resources section. Recommended starting points:
- Stop Guessing – white paper on why traditional debugging falls short for RTOS systems
- Tracealyzer Hands On – a series of short blogs with practical examples
Continuous Observability with Percepio DevAlert
Percepio also provides a cloud-connected solution for continuous observability in system testing, field testing and in deployment, Percepio DevAlert. This includes Tracealyzer support as well as remote debugging support on source-code level, for example on hard fault exceptions.
“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.”
“Percepio Tracealyzer enables unparalleled insight into the execution and timing 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 high-speed access to a running target system.”
“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.”
“It’s nearly impossible for developers to correct a safety, security, or performance issue if they can’t see or understand the problem. Percepio’s Tracealyzer provides extensive firmware visualization, which fosters a better understanding of the firmware. Developers using Tracealyzer on the PX5 RTOS platform can more easily enhance and optimize their firmware and swiftly debug issues, including the most difficult system crashes.”
FAQ: Embedded Software Development Tools
What is an embedded software development tool?
An embedded software development tool is any software that helps engineers write, debug, profile, or analyze code running on embedded hardware. The category spans compilers (GCC, IAR Embedded Workbench, Clang), hardware debuggers and probes (Segger J-Link, IAR I-Jet, Lauterbach), IDEs (STM32CubeIDE, Keil µVision), build systems, and specialized analysis tools like Tracealyzer that add observability into RTOS runtime behavior.
What tools do embedded software engineers typically use?
A typical embedded software toolchain includes a cross-compiler, a hardware debug probe, an IDE or build system, and increasingly, a dedicated observability or profiling tool. For RTOS-based systems on FreeRTOS, Zephyr, ThreadX or VxWorks, engineers also need visibility into the kernel itself. That is the gap Tracealyzer fills: it captures a continuous, timestamped log of RTOS events and makes them explorable visually, without halting the processor.
How does Tracealyzer differ from a traditional debugger?
A debugger halts the processor. Tracealyzer does not. It records task switches, semaphore operations, queue reads, timeouts, and custom user events while the system runs at full speed. This makes it the right tool for timing-sensitive bugs, race conditions, priority inversions, watchdog resets, and for performance bottlenecks that disappear the moment you attach a debugger. Tracealyzer and your existing debugger are not alternatives; they are complementary embedded system tools that work at different layers of visibility. Flyability reports doubling their development speed by using both.
Which processors and RTOS kernels does Tracealyzer support?
Tracealyzer provides prepackaged support for FreeRTOS, Zephyr, Eclipse ThreadX, SafeRTOS, PX5 RTOS, LynxOS-178, VxWorks and embedded Linux, as well as bare-metal C/C++ environments. On the hardware side, it runs on STM32, NXP i.MX RT, Xilinx Zynq, ESP32 and other Arm Cortex-M and Cortex-A devices. The Tracealyzer SDK enables additional OS and platform integrations for teams working outside the prepackaged list.
