Skip to main content

Ozone-Sim

High-speed embedded software simulation for debugging, coverage analysis, and CI/CD

  • Ultra-fast embedded software simulation with hundreds of millions instructions per second
  • Advanced backtracing, profiling, and live execution insights via seamless Ozone integration
  • Flexible deployment as an Ozone component, standalone simulator, or GDB server
Contact us Downloads Documentation
  1. 1.Key features
    1. 1.1.Ultra-fast simulation
    2. 1.2.Seamless Ozone integration
    3. 1.3.Flexible interface
  2. 2.Advanced analysis with Ozone
    1. 2.1.How integration into Ozone works
  3. 3.Using Ozone-Sim in other IDEs
  4. 4.Standalone operation
  5. 5.System requirements
    1. 5.1.Operating systems
    2. 5.2.Hardware
    3. 5.3.Licensing
  6. 6.FAQ

Key features

A circular gauge with a needle pointing to the right, indicating a level or measurement. The gauge is divided into segments and set against a gray background.

Ultra-fast simulation

Run embedded applications at speeds of hundreds of millions instructions per second. Accelerate software validation, regression testing, and automated build verification without requiring target hardware or a J-Link connection.

White icons of a gear, a diamond, a square, and a circle interconnected by lines, set against a gray circular background. The icons represent workflow or process mapping.

Seamless Ozone integration

Launch simulations directly from Ozone and use familiar debugging workflows, including source-level debugging, profiling, backtracing, live instruction counters, timeline analysis, and execution statistics.

Icon featuring three directional arrows within a circular grey background. One arrow points straight up, while the others curve left and right. The design symbolizes choices or multiple paths.

Flexible interface

Use Ozone-Sim as an integrated Ozone component, a standalone command-line simulator for automated testing, or a GDB server for third-party debugging tools. Easily integrate simulation into development workflows, CI pipelines, and automated test environments.

Advanced analysis with Ozone

Ozone-Sim can be used together with the Ozone debugger, allowing you to simulate application execution without target hardware. Switching between real hardware and a simulated environment is straightforward, making it easy to move between development, testing, and analysis. Ozone provides a range of system and performance analysis features that complement the simulator:

  • Profiling and performance analysis: Use Ozone's powerful analysis capabilities to gain insight into application behavior, execution flow, and performance bottlenecks.
  • Live instruction counters: Monitor instruction execution statistics in real time during program execution to identify efficiency issues immediately.
  • Backtrace support: Analyze call stacks and execution paths to simplify debugging and accelerate root-cause analysis.

More about Ozone

Live instruction counters

How integration into Ozone works

Combined with Ozone, Ozone-Sim enables efficient debugging, profiling, and automated testing in a single workflow.

1. Build the application

Compile and prepare the executable.

2. Configure the simulation

Launch Ozone and select Ozone-Sim as the target.

3. Load the executable

Import the firmware into the simulation environment.

4. Debug and analyze code

Run, inspect, profile, and validate firmware behavior.

5. Review execution insights

Review execution metrics and backtraces.

A flowchart showing connections between various software tools and a central GBD Server. Connected applications include Embedded Studio, Visual Studio Code, GDB Client, and Ozone Sim. Lines depict the relationships between these elements. The GBD Server is highlighted as a central component.

Using Ozone-Sim in other IDEs

Ozone-Sim includes an integrated GDB server interface, allowing it to be used with a wide range of third-party debuggers and development environments. This extends simulation capabilities beyond Ozone and enables use within existing development workflows.

  • Flexible toolchain integration: Incorporate hardware-free simulation into existing development environments and debugging workflows.
  • Standard GDB connectivity: Connect compatible tools through a standard GDB client connection for reliable, standardized communication between the simulator and external development tools.

Standalone operation

Ozone-Sim can function completely standalone, allowing you to run simulations directly from the command line without the Ozone GUI. This automated approach is ideal for continuous integration (CI) workflows, automated testing, and headless verification.

  • Automated CI/CD workflows: Seamlessly integrate hardware-free simulation into your automated test pipelines and continous integration environments.
  • Integrated semihosting support: Write test results, logs, and output data directly to files using the simulator's built-in semihosting functionality.
  • Command-line parameters: Easily pass custom test parameters via the command line using semihosting to control and customize simulation runs dynamically.
Code snippet showing a series of regression test functions being executed. It includes conditional statements to check if the number of passed tests matches the total, printing either failure or success messages accordingly. The last line returns 0 to indicate successful completion.
Code for regression test
Alt text: A screenshot of a Windows PowerShell window displaying the output of a regression test for a CortexM microcontroller. It includes logs of tasks performed, memory segments, and the result indicating that all tests passed successfully.
Regression test executed in Ozone-Sim

Supported target architectures

Ozone-Sim supports RISC-V and Arm architectures, as well as select Helium instructions, providing a flexible foundation for software development, debugging, and testing. Support for additional architectures and instruction set extensions may be added in future releases.

ArchitectureSupported targets
ArmArmv5, Armv6-M, Armv7-M, Armv7E-M, Armv7-A, Armv7-R, Armv8-M, Armv8-A (AArch32), Armv8-R (AArch32), Armv8.1-M*
RISC-VRV32 and RV64 with extensions A, C, D, E, F and M

* Armv8.1-M support excludes half-precision floating point and includes a subset of the M-Profile Vector Extension (Helium).

System requirements

Operating systems

Operating systemVersion
WindowsMicrosoft Windows (Arm/Intel)
macOSmacOS (Apple/Intel)
LinuxLinux
(List of supported distributions)

Hardware

Hardware componentItem
CPU1GHz or better
Memory1GB RAM
Disk space1GB
Abstract representation of a circuit board with intricate lines and patterns. The image features a microprocessor prominently, set against a dark background, emphasizing the technology theme. The overall tone is sleek and modern, suggesting advancements in electronics and computing.

Licensing

Ozone-Sim is bundled with and installed as part of the standard Ozone package but requires a separate license key. To use the full hardware-free simulation capabilities within the Ozone debugger, active licenses for both Ozone and Ozone-Sim are required.

You can evaluate the full feature set of Ozone-Sim free of charge. The 30-day evaluation period begins upon first use, whether Ozone-Sim is used within Ozone or as a standalone simulator. This allows developers to experience the high-speed simulation environment immediately without having to request a trial license.

FAQ

Can I test embedded software without target hardware?

Yes. Ozone-Sim allows developers to simulate and validate embedded applications without target hardware or a J-Link connection, enabling faster development and automated testing workflows.

Does Ozone-Sim support third-party debugging tools?

Yes. Ozone-Sim can operate as a GDB server, allowing compatible third-party debuggers and development environments to connect using the standard GDB protocol.

How does Ozone-Sim integrate with Ozone?

Integration is completely effortless. Since Ozone-Sim is natively bundled with Ozone, it is ready to use right out of the box. You simply launch Ozone and select Ozone-Sim as your target device directly within the project configuration. Ozone automatically handles the rest behind the scenes, instantly unlocking full source-level debugging, profiling, and live analysis capabilities without needing external configuration.

How fast is Ozone-Sim?

Ozone-Sim can execute embedded applications at speeds of up to 700 million instructions per second (on an AMD Ryzen 9), enabling rapid software validation, regression testing, and automated build verification.

What analysis and debugging capabilities does Ozone-Sim provide?

Ozone-Sim supports advanced analysis and debugging features, including profiling, backtracing, live instruction counters, execution statistics, and timeline analysis to help identify performance issues and simplify root-cause analysis.

Do I need a J-Link debug probe to use Ozone-Sim?

No. Ozone-Sim is a pure software simulator. You can run, debug, and profile your embedded applications entirely hardware-free, without requiring a physical J-Link or target board.

Is Ozone-Sim suitable for automated CI/CD pipelines?

Absolutely. Ozone-Sim features a powerful standalone mode that allows headless execution directly from the command line. With integrated semihosting support, you can pass test parameters and log test results directly to files, making it perfect for regression testing and continuous integration.

Which architectures are currently supported?

Ozone-Sim supports Arm (including Arm v5, v6, v7, v8 (ARM32), and select Helium instructions) as well as RISC-V architectures. We are continuously expanding instruction set support.

Can I use Ozone-Sim with debuggers other than Ozone?

Yes. Thanks to its integrated GDB server interface, Ozone-Sim acts as a standard GDB target. You can easily connect it to third-party IDEs, including Visual Studio Code, SEGGER Embedded Studio, or any generic GDB client.

What is semihosting, and how does Ozone-Sim utilize it?

Semihosting is a mechanism that allows an embedded application running on the simulator to communicate directly with the host PC. Ozone-Sim features built-in semihosting support, enabling your simulated code to perform input/output operations—such as reading configuration files, printing debug messages, or writing test logs—directly on your development machine or CI/CD server.

Can I use semihosting for automated regression testing?

Yes, absolutely. This is one of the primary use cases for Ozone-Sim's standalone mode. You can pass test parameters to your application via the command line and use semihosting to read test vectors from files and to write the test results or execution logs. This allows for fully automated, headless verification without human intervention.

Related content

Get in touch with us

Have questions or need assistance? Our Embedded Experts are here to help!

Reach out to us for:

  • Licensing quotes
  • Technical inquiries
  • Project support

 

Contact us