For Linux C/C++/Java/Kotlin/Go/Rust

Find defects before your customers do

Time travel debugging (for large-scale codebases) that just works

Resolve customer issues quickly without needing a reproducer
Diagnose multithreading issues (e.g. race conditions or deadlocks) in hours, not weeks
Troubleshoot new regressions, test failures and flaky tests with less engineering effort

100% compatible with GDB, so no need to learn a new tool – just a handful of new commands.

Also available as a Visual Studio Code extension or CLion plugin.

What is
Time Travel Debugging?

Record a process. Replay the recording. Resolve the issue.

Reconstruct and examine the full state of the program at any point in time. Step back in the execution history to inspect the code flow to see what happened.

Record

Record the bug (on demand or in automated test), capturing the full program execution in a single binary file.

No code or build changes are required thanks to Undo’s just-in-time binary instrumentation.

Replay

Any question you have can be answered from a recording. No more “how did that happen?”.

Recordings are portable, so they can be replayed outside of the original environment and shared with your team.

Resolve

Examine the full state of the program at any point. Go back and forward in time with ease.

Trace from symptom to root cause in one cycle – without having to restart your debug session or recompile.

FREE TRIALSEE A DEMO

No extra set up steps required.
Get started in 2 minutes.

Solve your hardest bugs, fast

  • Diagnose memory corruptions, race conditions, intermittent bugs, or incorrect behaviors within hours, not weeks
  • Quickly rewind to the point of failure in the debugger to understand the root cause
  • Step backward or forward, or jump to any point in the execution history to see what happened – without having to restart the process again

Watch the Demo

FREE TRIALSEE A DEMO

No extra set up steps required.
Get started in 2 minutes.

Image link

Understand Code You Didn’t Write

Unfamiliar with the codebase? No problem! You don’t have to have it all in your head.

A recording captures the whole execution history – every line of code in every thread, every variable, every I/O. So all you have to do is to rewind and fast-forward in time in the recording to observe how state changes and why the code behaves the way it does.

  • Get a picture of code flow by exploring how the code is executed dynamically
  • See exactly what happened and how it happened
  • Understand subtle interactions amongst complex components

Will Undo work with my code?

Please select a tab from the left-hand side to view more information.

Many real-world programs can be recorded running at better than half-speed. Others will be a bit worse – in general, expect 1.5x-5x slowdown per thread (YMMV).

Undo’s dynamic just-in-time instrumentation captures only the minimum data required to replay the process – 99% of the program state can be reconstructed on demand, only the non-deterministic inputs need be recorded.

👉 Check out performance benchmarks

Undo’s customers record applications:

  • with dozens of active threads and 100’s of less active threads
  • using custom memory allocators, custom thread libraries
  • running on machines with 100’s of cores and terabytes of RAM

For example, the SAP HANA Cloud engineering team invests in the most advanced technologies to ensure stable releases. The team uses Undo’s time travel debugging (combined with thread fuzzing) to debug their highly-multithreaded application with around 5 million lines of productive C++ code. No known bug remains unresolved.

👉 Read the SAP HANA interview

To record memory states, the Undo engine relies on the copy-on-write semantics provided by the operating system, so the memory footprint can be kept relatively low (typically 2x that of the process you are recording).

We can also tune Undo’s behavior adaptively to available RAM.

👉 Learn more

Undo comes as on-premise software, so your data lives with you.

A good proportion of our customers use Undo in production to resolve customer issues orders of magnitude faster than with decade-old debugging practices.

👉 Check out customer stories from Synopsys, Siemens EDA, Cadence or Altair

 

 

Undo has the technology to record almost any kind of interaction between the process being recorded and the kernel.

Some of Undo’s customers are networking companies, using very specialized hardware and kernels. Some kernel interactions involving custom devices require optimization by Undo to have good reliability and performance.

Undo’s software is designed for Linux, running on x86, x86_64 and ARM64 devices.

We don’t support Risc-V, PPC or MIPS. We cannot record on Windows, MacOS, any of the BSDs or any other OS that is not Linux. On Linux we do support a huge variety of kernel versions and distros.

We cannot record code executed by GPUs, but we can record the CPU side of the interaction with a GPU and, sometimes, that’s all you need.

TRUSTED BY INDUSTRY LEADERS

TRUSTED BY INDUSTRY LEADERS

Integrates with all popular
CI / Test Automation Tools & IDES

Flexible APIs and CLI tooling make it easy to integrate with custom test environments too
Image link
Image link

Step Into A
Time Machine

  • See what your software really did
  • Solve hard bugs – fast
  • Understand unfamiliar codebases
START YOUR FREE TRIAL

No extra set up steps required.
Get started in 2 minutes.

Available For Linux Applications

THE ULTIMATE GUIDE TO
TIME TRAVEL DEBUGGING

Image link