Skip to main content
SEGGER Ozone-Sim
SEGGER SEGGER

Ozone-Sim

Compilers & IDEs

Ozone-Sim is SEGGER's high-speed instruction set simulator for Arm and RISC-V: hardware-free debugging, profiling, coverage and CI/CD testing with no J-Link or target board. India evaluation and FAE-led support from GSAS.

Type

Instruction set simulator (Arm + RISC-V)

Speed

Up to 700M instr/sec (AMD Ryzen 9, per SEGGER)

Target hardware

None required, pure software

Deployment

Ozone component, standalone CLI, GDB server

Analysis

Profiling, backtrace, live instruction counters, coverage

Semihosting

Built-in, file I/O and test logs

OS

Windows, macOS, Linux

License

30-day evaluation, licensed with Ozone

Authorized SEGGER partner
Local FAE & application engineering
Hands-on training & integration
Manufacturer warranty

About Ozone-Sim

SEGGER Ozone-Sim is a high-performance instruction set simulator for Arm and RISC-V that runs embedded applications directly on a PC, with no target hardware and no J-Link required. It ships bundled with the standard Ozone package but needs a separate license key, and it lets development, debugging, and automated testing start long before production hardware is available.

Ozone-Sim hardware-free instruction set simulator, buy and evaluate in India from GSAS

Key features

FeatureDescription
Instruction Set SimulationRuns Arm and RISC-V applications entirely in software, no target board or J-Link needed
High Simulation SpeedHundreds of millions of instructions per second, up to 700 million instructions/sec on an AMD Ryzen 9 (per SEGGER)
Ozone IntegrationSource-level debugging, profiling, backtracing, live instruction counters, timeline analysis, execution statistics, and code coverage
Standalone CLI ModeHeadless command-line simulator for automated and unattended testing
Built-in SemihostingRead config or test vectors, write logs, results, and output to files; pass parameters via the command line
GDB ServerIntegrated GDB server interface connects third-party debuggers and IDEs over the standard GDB protocol
Real/Simulated SwitchingMove between real hardware and the simulated environment without changing your analysis workflow
Cross-PlatformNative builds for Windows, macOS, and Linux

How Ozone-Sim works with Ozone

  1. Build the application: compile and prepare the executable as usual.
  2. Configure the simulation: launch Ozone and select Ozone-Sim as the target/host interface.
  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: examine execution metrics and backtraces.

Once Ozone-Sim is running, the debugging and analysis features are the same ones Ozone already provides on real hardware: source-level and assembly debugging, profiling, backtrace support, live instruction counters, and code coverage. Switching between a real J-Link/J-Trace connection and the simulated target is straightforward, and Ozone-Sim can display real-time code coverage and profiling just as when debugging on real hardware with J-Trace, then export that information to help automatically identify functional or performance deviations.

Hardware-free testing and CI/CD

Ozone-Sim’s standalone command-line mode is built for headless and automated testing, the mode most teams reach for once they want simulation inside a build pipeline rather than an interactive debug session.

Ozone-Sim standalone command-line simulator running a headless test, hardware-free CI/CD for embedded teams in India

Built-in semihosting is what makes this practical for regression testing: the simulated program can read configuration or test vectors, then write logs, results, and other output directly to files, with parameters passed in over the command line. That turns Ozone-Sim into a repeatable, scriptable test target that a CI/CD pipeline can call the same way it calls any other build step, no lab hardware, no probe contention between engineers, no waiting for a free test rig.

Ozone-Sim regression test results, automated hardware-free embedded software testing for CI/CD pipelines in India

For teams that also validate on physical targets, J-Trace PRO hardware-in-the-loop trace remains the reference point Ozone-Sim results can be checked against.

Using Ozone-Sim in other IDEs (GDB server)

Ozone-Sim is not limited to the Ozone application. It includes an integrated GDB server interface, so third-party debuggers and IDEs, including Visual Studio Code, SEGGER Embedded Studio, or any generic GDB client, can connect to the simulator over the standard GDB protocol. Teams that already have a GDB-based debug workflow can point it at Ozone-Sim and get hardware-free simulation without changing their day-to-day IDE.

How Ozone-Sim compares to QEMU and Renode

Teams evaluating hardware-free simulation often weigh Ozone-Sim against the two established open-source options, QEMU and Renode. They solve overlapping but different problems, and the honest trade-off is fidelity versus integration and support.

ToolWhat it isStrengthsWhere it fits
Ozone-SimCommercial instruction set simulator for Arm and RISC-VExecution speed (up to 700 million instructions/sec on an AMD Ryzen 9, per SEGGER), native profiling, coverage, backtrace and timeline inside the Ozone debugger, GDB server, SEGGER supportFast firmware regression, coverage, and debugging in the same tool you already use on real J-Link hardware
QEMUOpen-source emulatorFull-system Linux emulation across many architectures, ubiquitous, freeOS and kernel bring-up; for bare-metal microcontroller work, peripheral models are often stub-only and timing is not cycle-accurate
RenodeOpen-source simulator (Antmicro)Models CPUs, peripherals, and external devices; strong at multi-node and networked-system simulation and CISystem-level scenarios where modeling peripherals and multiple connected nodes matters

Ozone-Sim does not set out to reproduce peripheral electrical behavior or cycle-exact timing, which is where QEMU’s full-system emulation and Renode’s peripheral models have the edge. Its advantage is speed and running inside the same Ozone debugger and workflow that engineers already use on physical targets, so there is no second tool to learn and no discontinuity between simulated and real-hardware debugging. For tests that depend on real peripheral timing or electrical behavior, pair simulation with J-Trace PRO hardware-in-the-loop trace.

Supported architectures

FamilySupported 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 the A, C, D, E, F, and M extensions

*Armv8.1-M support excludes half-precision floating point and includes a subset of the M-Profile Vector Extension (Helium). SEGGER notes that support for additional architectures and instruction-set extensions may be added in future releases.

System requirements

RequirementDetail
Operating systemsWindows (Arm/Intel), macOS (Apple/Intel), Linux (see SEGGER’s supported-distributions list)
CPU1 GHz or better
RAM1 GB
Disk1 GB

Licensing and evaluation

Ozone-Sim is bundled with and installed as part of the standard Ozone package, but it requires a separate license key. Full hardware-free simulation inside Ozone needs active licenses for both Ozone and Ozone-Sim. SEGGER offers a 30-day evaluation of the full feature set, with the trial period beginning on first use, whether inside Ozone or as a standalone simulator, and no trial-license request needed to get started.

Ozone-Sim in India with GSAS

GSAS is SEGGER’s authorized engineering partner in India, and Ozone-Sim is where our field application engineers add the most value before a single license changes hands. Getting real use out of a hardware-free simulator, wiring it into an existing CI/CD test rig, choosing standalone CLI versus the GDB server for a given IDE, mapping semihosting output to your existing log pipeline, is application engineering, not invoicing. Our FAEs across Bengaluru, Chennai, Hyderabad, Pune, Mumbai, and Delhi NCR work directly with teams evaluating Ozone-Sim for early software bring-up, including RISC-V teams building on Shakti and Vega cores who want to start firmware validation before silicon or boards arrive. Talk to GSAS about evaluating Ozone-Sim, or request a quote once you’re ready to license alongside Ozone.

Ozone-Sim in Action

SEGGER Ozone-Sim: debug embedded firmware with no hardware (GUI, CLI and CI/CD demo)

SEGGER Ozone-Sim: debug embedded firmware with no hardware (GUI, CLI and CI/CD demo)

Common questions about Ozone-Sim

Can I test embedded software without target hardware?
Yes. Ozone-Sim simulates and validates Arm and RISC-V applications with no target board and no J-Link, so development and automated testing can start before hardware is available.
Do I need a J-Link debug probe to use Ozone-Sim?
No. Ozone-Sim is a pure software simulator, so you can run, debug, and profile firmware entirely hardware-free.
How fast is Ozone-Sim?
It runs embedded applications at hundreds of millions of instructions per second, up to 700 million instructions per second on an AMD Ryzen 9 (per SEGGER), fast enough for regression testing and automated build verification.
Which processor architectures does Ozone-Sim support?
Arm (Armv5 through Armv8, AArch32, plus a subset of Armv8.1-M Helium) and RISC-V (RV32 and RV64 with the A, C, D, E, F and M extensions).
Can I use Ozone-Sim in CI/CD pipelines?
Yes. A standalone command-line mode runs headless, and built-in semihosting lets you pass test parameters and write logs and results to files for fully automated regression testing.
Can I use Ozone-Sim with IDEs other than Ozone?
Yes. Its integrated GDB server lets Visual Studio Code, SEGGER Embedded Studio, or any generic GDB client connect over the standard GDB protocol.
What analysis features does Ozone-Sim add inside Ozone?
Source-level debugging, profiling, backtracing, live instruction counters, timeline analysis, execution statistics, and code coverage.
What is semihosting and how does Ozone-Sim use it?
Semihosting lets the simulated program do host I/O, reading config or test vectors and writing debug output, logs, and test results directly on your PC or CI server.
Which operating systems does Ozone-Sim run on?
Windows (Arm/Intel), macOS (Apple/Intel), and Linux.
How can I evaluate Ozone-Sim, and is it licensed separately from Ozone?
Ozone-Sim installs as part of the standard Ozone package but needs its own license key, separate from the Ozone debugger license and not included with J-Link probe licenses. A 30-day full-feature evaluation starts on first use, with no trial-license request needed. GSAS field application engineers in India help teams set up the evaluation and wire it into their build and CI workflow.
Is Ozone-Sim the same as Ozone's third-party simulator support announced in 2025?
No. In September 2025 SEGGER opened Ozone, its debugger, to work with third-party debug probes and simulators over the GDB Remote Protocol. Ozone-Sim, launched separately in June 2026, is SEGGER's own instruction set simulator for Arm and RISC-V and needs no third-party hardware or software.
Is Ozone-Sim a simulator or an emulator?
Ozone-Sim is a simulator, not an emulator, in the embedded-tooling sense: it runs entirely in software with no physical hardware standing in for the target processor. That distinguishes it from in-circuit emulation, where dedicated hardware reproduces the real chip's true real-time behavior.
How is Ozone-Sim different from QEMU or Renode?
QEMU and Renode are open-source. QEMU is strongest for full-system Linux emulation across architectures, and Renode adds peripheral and multi-node modeling. Ozone-Sim is a commercial instruction set simulator whose strengths are execution speed and native integration with the Ozone debugger's profiling, coverage, and backtrace tools, plus a GDB server and SEGGER support. It focuses on running your firmware fast, not on modeling peripheral electrical behavior.
Can Ozone-Sim validate a RISC-V core like Shakti or Vega before tape-out?
No. Ozone-Sim validates the software that runs on a target, application code, RTOS ports, and drivers, against its instruction set, not the processor's RTL. Validating the silicon design itself before tape-out is a separate discipline, pre-silicon hardware verification, handled by different tools.

Interested in Ozone-Sim?

Get pricing, an evaluation unit, or a technical consultation from our application engineers.

Request a Quote Demo