Every code coverage metric, language and integration in one tool
RKTracer measures every code coverage metric, from function and statement to branch, condition, MC/DC, multi-condition and delta, across 10 languages, every compiler and cross-compiler, with IDE plugins, CI integration and SonarQube publishing.
No source changes · MC/DC for C and C++ · HTML, XML and SonarQube reports
# Prefix your build, run tests, report $ rktracer make all && ctest $ rkresults --report html ✓ function 100% ✓ statement 100% ✓ decision 100% ✓ condition 100% ✓ MC/DC 99.2% multi-cond 94.0% · delta 100%
One code coverage tool, every metric and toolchain
RKTracer is a code coverage tool built for teams whose software cannot fail. It measures the full set of code coverage metrics, from line and statement all the way up to MC/DC and multi-condition, and it does so without touching your source code or rewriting your build. You prefix your existing build command, run your tests however you already run them, and get an evidence-grade report.
This page is the complete reference for those code coverage features: the metrics RKTracer reports, the 10 languages it understands, the compilers and cross-compilers it auto-detects, the build systems and IDEs it plugs into, the targets and platforms it runs on, the report formats it produces, and the CI and SonarQube integrations it ships with. RKValidate is an ISO 9001 quality-certified vendor, and RKTracer is built to the same standard.
Every code coverage metric, from line to MC/DC
RKTracer reports the basics and the hardest structural metrics in software assurance, side by side, in a single run.
Function, File & Line
Know which functions, files and lines your tests execute, down to the line and color-coded in the report.
Statement & Branch/Decision
Confirm every statement runs and that both the true and false outcomes of each decision are tested.
Condition & MC/DC
Show each condition takes both values, then that it independently affects the outcome. MC/DC for C and C++.
Multi-Condition & Delta
Exercise every combination of conditions, then focus coverage on exactly the code that changed each build.
Line coverage alone is not enough for critical software
Assurance standards do not just ask "did the line run?" They ask "was every condition independently shown to affect the outcome?" That is MC/DC, and it is the structural coverage the highest assurance levels call for. RKTracer measures it natively for C and C++, alongside every other metric.
RKValidate is an ISO 9001 quality-certified vendor. RKTracer measures the code coverage metrics these standards reference; it does not itself carry a functional-safety certification.
| Coverage metric | Called for at |
|---|---|
| Statement | DO-178C Level C · ISO 26262 ASIL A |
| Decision / Branch | DO-178C Level B · ASIL B/C · EN 50128 |
| MC/DC | DO-178C Level A · ASIL D |
| Multi-Condition | Deep verification · IEC 61508 SIL 4 |
Standards are listed only to show which metric each one references, not as a certification claim.
Ten languages, one code coverage model
The same coverage metrics, the same report, across your whole codebase. MC/DC is supported for C and C++.
| Language | Standards, runtimes & toolchains |
|---|---|
| C | C89, C90, C95, C99, C11, C17, plus OpenMP and OpenACC. MC/DC supported. |
| C++ | C++98, C++03, C++11, C++14, C++17, C++20, C++23. MC/DC supported. |
| CUDA | NVCC toolchain, coverage on GPU kernels and host code. |
| Rust | Cargo and rustc-based builds. |
| C# | Microsoft CSC, Mono, .NET Roslyn, Visual Studio 2005 and later. |
| Java | Java 7 and later, Sun, Oracle and OpenJDK. |
| JavaScript | Node.js V8, JSX for React, JerryScript. |
| TypeScript | Node.js toolchains, transpiled and source-mapped coverage. |
| Go | Go 1.5.4 and later. |
| Python | Python 2.7 and later, CPython, IronPython, Jython, Nuitka, PyPy, MicroPython. |
See language-specific guides in the documentation for C, C++, Java, .NET and Python.
Auto-detects every compiler in your toolchain
No compiler flags to manage and no wrappers. RKTracer detects the compiler from your build and instruments at compile time, even when cross-compiled.
Host & desktop
- GNU gcc and g++
- LLVM and Clang
- Microsoft Visual Studio (2005 and later)
- Intel (icc and icl)
- NVCC for CUDA
- Borland, Paradigm and Embarcadero
Embedded & cross
- IAR (all icc variants)
- ARM and Keil armcc
- Keil and Raisonance (c51, c251, c166, cx51)
- Green Hills compilers
MCU toolchains
- Texas Instruments (armcl, cl16x, cl2000, cl430, cl55, cl500, cl6x, clpru, cl-arp32)
- Microchip MPLAB (xc8-cc, xc16-gcc, xc32-gcc, pic10 to pic18)
If your compiler is not listed, tell us your toolchain and we will map RKTracer to it.
Step-by-step compiler guides include IAR Embedded Workbench, Visual Studio and 30+ more.
Plug into the build you already use
RKTracer wraps your existing build invocation. No build-system surgery, no migration.
Make & native
- GNU Makefile
- gmake
- nmake
- Cygwin
- QT Makefile
- SCons
CMake & MSBuild
- CMake (Visual Studio)
- CMake (MinGW)
- CMake (nmake)
- CMake (GNU)
- MSBuild
JVM, .NET & more
- dotnet (.NET Core)
- Gradle
- Maven
- Ant
- Bazel
See worked examples for CMake applications, Makefile projects and every other build system.
Measure coverage from inside your IDE
Enable the plugin and build as usual. RKTracer captures coverage on the same target you debug.
Desktop & JVM
- Visual Studio
- Eclipse
- NetBeans
Arm & MCU
- IAR Embedded Workbench
- Keil uVision / MDK-ARM
- DS-5 Arm
- MPLAB
Silicon vendor
- Code Composer Studio
- Simplicity Studio
- Renesas e2 studio
- Green Hills MULTI
Mobile & embedded OS
- Android Studio
- Tizen
The same code coverage metrics across your whole stack
Targets
- Host machines & servers
- Embedded targets (with or without a file system)
- Constrained devices
- GPUs & CUDA
- Simulators & emulators
Architectures
- Intel x86 / x64
- ARM
- IA64
- PowerPC
- SPARC
- MIPS
- AURIX TriCore
On targets without a file system, coverage data streams out over your existing debug transport or a RAM buffer.
Operating systems
- Linux (32 and 64-bit)
- Windows (32 and 64-bit)
- macOS (32 and 64-bit)
- Custom in-house OS platforms
Reports your team and your auditors can read
RKTracer publishes interactive HTML reports at project, file and function level, with source color-coded to the line. Delta and new-line views show coverage for exactly what changed, and XML exports plus SonarQube publishing feed your dashboards.
- HTML at project, file and function level
- Delta and new-lines views for changed code
- XML exports for custom tooling
- SonarQube publishing, all versions
- Merge reports across multiple runs
Color-coded to the line: green fully covered · amber partial · red uncovered.
Code coverage metrics in every pipeline run
Add RKTracer to your build stage and publish coverage on every commit, with the same metrics you see locally.
Jenkins
Publish HTML and XML coverage as a build artifact and gate on coverage thresholds.
Azure DevOps
Run coverage in your pipeline and surface results in the build summary.
GitLab CI
Drop coverage into your .gitlab-ci.yml and report per-merge-request.
SonarQube
Publish coverage to SonarQube, all versions, alongside your quality gates.
Focus coverage on exactly what changed
Whole-project coverage is the long game. On a pull request, what you really want to know is whether the lines you just touched are tested. RKTracer reports delta coverage and a new-lines view that isolate the code introduced or modified since a baseline, so reviewers can gate on the change itself.
- Coverage scoped to changed and new lines
- Every metric, including MC/DC for C and C++
- Merge runs to track coverage over time
Gate the merge request on the delta, not the whole project, so new code never lowers your coverage baseline.
Coverage finds the gaps. Two ways to close them.
RKTracer pinpoints the uncovered lines, decisions and MC/DC conditions. Turning those gaps into tests is your choice, and both options below are part of the RKTracer tool.
RKTracer itself measures coverage; it does not generate tests. The two tools below do.
Compare RKMCP and RKTracerGenRKMCP · AI-assisted
An MCP server that streams the uncovered lines, decisions and MC/DC conditions to your AI agent. The AI writes unit and functional tests plus the build, then runs and re-checks until the gaps close.
RKTracerGen · offline
A deterministic, fully offline unit-test generator. Boundary-Value Analysis, managed stubs and a standalone build that compiles and runs locally. No AI, no tokens, no network.
Code coverage metrics and features, answered
See every code coverage metric on your own code
Download the free 30-day trial and run RKTracer on your toolchain and target today, or book a 30-minute demo with a coverage engineer.
More on the RKTracer overview and how it works.