Reliable code coverage.
Every language. Every target.
RKTracer measures every coverage metric, including MC/DC, multi-condition and delta, across embedded targets, GPUs, simulators and hosts, without changing your build. Then it hands the uncovered lines and conditions to your AI agent, so the AI writes the tests that close the gaps.
Coverage that fits how you already build & test
One coverage engine for every place your code runs
AI can write tests. It can't see what's still untested.
Coverage is the ground truth AI test generators are missing. RKTracer measures every metric, through MC/DC, on the code as it actually runs, then hands your AI agent the exact uncovered lines and conditions over MCP. RKTracer measures the gaps; your AI writes the tests that close them.
Measure on the real target
Coverage on the actual silicon: Cortex-M, GPU & CUDA, DSP, RTOS or bare-metal, host or target, with or without a file system, across every compiler and cross-compiler.
Every metric, through MC/DC
Function, file, statement, line, decision, condition, multi-condition, MC/DC and delta: the structural metrics functional-safety standards require, and most tools never measure.
Feed the gaps to your AI
The built-in RKMCP server exposes your covered and uncovered lines and conditions as JSON-RPC over MCP, so your AI agent can generate the unit tests that close them.
Coverage that follows your code all the way to the target
Most coverage tools stop at line and branch coverage on the host. RKTracer measures the deeper structural metrics, including MC/DC, multi-condition and delta, on the hardware your code actually runs on, and turns the gaps into data your AI can act on.
- MC/DC, multi-condition & delta, not just statement %
- Runs on embedded targets, GPUs & simulators, not only the host
- Feeds uncovered lines & conditions to your AI agent via MCP
| Capability | Typical coverage tool | RKTracer |
|---|---|---|
| Setup | Wrappers, env, build edits | Prefix the build |
| Source changes | Sometimes | None |
| MC/DC & multi-condition | Often missing | Native |
| Embedded / GPU / simulator | Host-focused | All targets |
| CUDA coverage | No | Yes |
| Delta coverage | Rare | Yes |
| AI-ready gap data (MCP) | No | Yes |
Comparison reflects common capabilities of mainstream coverage tools; individual tools vary.
Every metric the standards ask for
From the basics to the hardest structural metric in software assurance.
Function, File & Line
Know exactly which functions, files and lines your tests execute.
Statement & Branch/Decision
Confirm every statement runs and both outcomes of each decision are tested.
Condition & MC/DC
The strongest structural metrics, the ones the highest assurance levels require.
Multi-Condition & Delta
Go beyond MC/DC, and focus coverage on exactly what changed each build.
Coverage for wherever your code lives
Unit, Integration & Functional Testing
Measure unit and integration coverage from the first commit through to system integration.
Embedded Systems
Coverage on real targets, with or without a file system, across every cross-compiler.
Host & GPU
Bring structural coverage to accelerator and parallel-compute workloads.
Android Apps
Measure coverage on host, emulator or device in a repeatable CI workflow.
Web & UI Testing
Turn Selenium automation runs into precise application coverage.
Drivers & Kernel
Instrument and cover kernel modules and low-level device drivers.
10 languages. One coverage standard.
From bare-metal C to modern Rust and Go, RKTracer speaks your stack, and applies the same rigorous coverage model to all of it.
See all supported languages & compilersFrom your build to coverage and AI-ready gaps
Prefix your build
Add the rktracer keyword to your existing build. It works with any build system and any compiler or cross-compiler. Source is instrumented automatically; nothing else changes.
Run your tests, any way
Run unit, integration, functional or UI tests on host, simulator, emulator or the real target (incl. GPU & CUDA). The runtime is linked in automatically, even when cross-compiled.
Get the coverage report
Function through MC/DC, multi-condition and delta, including on-device coverage, with low overhead, in HTML and XML.
Hand the gaps to your AI
The RKMCP server serves the uncovered lines and conditions as JSON-RPC over MCP, so your AI agent can write the unit tests that close them.
Two ways to turn uncovered code into tests
RKTracer finds exactly what is untested, through MC/DC. Then you choose how to close the gaps: hand them to the AI agent you already use with RKMCP, or generate the unit tests fully offline with RKTracerGen. Both are part of the RKTracer tool.
Stream the uncovered code to the AI agent you already use, and let it write and run the tests.
Point it at one function or a whole file. It writes, builds and runs the unit tests, with no AI and no network.
| At a glance | RKMCP | RKTracerGen |
|---|---|---|
| Needs AI | Your AI agent | No, fully offline |
| Tests it produces | Unit and functional | Unit, boundary values |
| Calls inside the unit | Handled by the AI | Stubbed by default |
| What you get | AI-written tests and build | Harness, stubs and Makefile |
| Build and run | The AI compiles and runs | Builds and runs the binary locally |
| Running cost | AI tokens and compute | None, no tokens |
| Scope | Across the project via the agent | Per function or per file |
Both build on the same RKTracer coverage engine, and suit safety-critical workflows that follow IEC 61508, ISO 26262, EN 50128 or DO-178C.
Teams have shipped with RKTracer for years, not weeks
Engineering teams in medical devices, climate systems and embedded software have relied on RKTracer for three to four years. A few words from them.
"We use RKTracer to get our test-coverage matrix across both unit and functional or integration testing. The coverage gaps it surfaces let us write better tests and catch bugs that would otherwise stay hidden, and it even helps us spot dead code. On-target C coverage is something our earlier Python tooling could not match, and any issue we raised has been resolved in a software update."
"RKTracer streamlined our coverage analysis with precise metrics that pinpoint untested paths, which has raised our test quality and our confidence in every release. It uncovers gaps other tools missed, even across our BSP layer and multi-threaded modules, and it slots cleanly into our CI/CD pipeline. The accuracy, the reporting and the support have all been excellent."
Measure real coverage. Let your AI close the gaps.
Try RKTracer free on your own code, host or target, and see full MC/DC coverage in an afternoon.