AQTime Is Shutting Down. Here’s What Replaces It.

SmartBear has confirmed that AQTime will reach end of life in June/July 2026. If you’re using AQTime for memory analysis, code coverage, or performance profiling, you need to find a replacement.

This post covers what replaces what, what you gain in the migration, and the one gap we’re honest about. For a complete profiler-by-profiler mapping, see the AQTime migration guide.

What AQTime covered

AQTime was a single product that bundled 15 profilers: memory leak detection, resource tracking, COM reference counting, code coverage (two variants), performance profiling (instrumented and sampling), plus several secondary tools for exception tracing, fault injection, function tracing, and static analysis.

The appeal was obvious — one licence, one UI, one installation. The three capabilities that most developers actually used were: memory analysis, code coverage, and performance profiling. Those three map directly to three Software Verify products.

The thing worth knowing before you migrate

AQTime’s native-code profiling support stopped at Visual Studio 2010.

That’s not a typo. AQTime’s profilers for unmanaged C++ code support MSVC version 4 through 10 — that’s Visual Studio up to and including VS 2010. Any developer writing C++11, C++14, C++17, C++20, or C++23 in Visual Studio 2012 or later cannot fully use AQTime’s native profilers. The documentation hasn’t been updated since January 2022, and the compiler support hadn’t been updated for years before that.

If you’ve been struggling to get meaningful results from AQTime on a modern build, this is likely why.

Our tools support MSVC from Visual C++ 6 through Visual Studio 2026. Every version in between. The same applies to GCC, Clang, Delphi, and Rust — if we can read debug information from the compiler, we can instrument the application.

Memory analysis → Memory Validator

AQTime split memory tracking across three separate profilers:

• The Allocation Profiler tracked heap memory — but allocation tracking was disabled by default. You had to specifically enable “Check system memory allocations” before any allocation data appeared. Their own documentation acknowledged this generated lots of results and could cause out-of-memory issues within AQTime itself.
• The Resource Profiler tracked Windows handles, GDI objects, fonts, brushes, bitmaps, registry handles, COM objects, and print spooler entries.
• The Reference Count Profiler tracked COM AddRef/Release on interface objects.

Memory Validator covers all three in one tool, with everything enabled by default. You don’t prepare a project, don’t configure which resource types to track, and don’t worry about which profiler covers which category. Load your application, run it, see what leaked.

On top of what AQTime covered, Memory Validator also tracks GDI handles, Windows kernel handles, and .NET handles — all of which AQTime’s Resource Profiler did not track separately. If GDI exhaustion or Windows handle exhaustion has been a problem you’ve been debugging manually, Memory Validator surfaces these automatically.

Code coverage → Coverage Validator

AQTime offered two coverage tools: Coverage Profiler for thorough line-by-line tracking with hit counts, and Light Coverage Profiler for faster runs without hit counts — useful for daily regression testing.

Coverage Validator handles both use cases through a single instrumentation setting. The default mode gives full line coverage with visit counts at practical speed. If you need maximum throughput for a regression pipeline, switching to the lighter instrumentation mode takes seconds. AQTime required two separate products; we handle it with one dial.

Coverage Validator supports every compiler version AQTime’s coverage profiler supported, and every compiler version AQTime’s profiler never got to: VS 2012 through 2026, modern GCC, Clang, Delphi, Rust.

Performance profiling → Performance Validator

AQTime’s Performance Profiler was an instrumented profiler with 13 measurement counters — elapsed time, CPU cache misses, context switches, page faults, and several others. It also had a documented BSOD risk when certain counters were used with the Windows DDK installed, and timing accuracy caveats for SpeedStep processors and virtual machines.

Performance Validator is an instrumented profiler with a sampling option. The instrumented mode gives exact call counts, complete call graphs, and line-level timing. It works with any application where debug information is available — which means VS 6 through 2026, Delphi, GCC, Clang, and anything else that produces a PDB, TDS or DWARF output. No BSOD risk, no hotfix requirements.

AQTime also had a Sampling Profiler — statistical profiling that polls at intervals rather than instrumenting every call. It was unmanaged code only, and their documentation recommended quad-core hardware for accuracy. Performance Validator covers both approaches: use instrumented mode for exact call counts and full call graphs, or switch to sampling mode when you want lower overhead.

The gap we’ll be honest about

AQTime’s Failure Emulator injected controlled failures into Windows API calls — COM failures, file access failures, memory allocation failures, registry failures — to test how an application handles error paths. This is genuinely useful work: most applications handle the happy path well and fall apart when malloc returns NULL or a registry key goes missing.

We don’t have a direct equivalent right now. Fault Validator is something we plan to build — AQTime’s Failure Emulator showed the demand was real, and their exit leaves a gap in the market. If fault injection was a core part of your workflow, we don’t have a replacement today and we’re not going to pretend otherwise.

AQTime’s Function Trace

AQTime’s Function Trace profiler logged every function call with actual parameter values — a powerful debugging aid for tracing exact execution paths. Our equivalent is Bug Validator, which records parameter values, local variable values, and register values at every function entry, exit, and line visit. It covers more than AQTime’s Function Trace did. The honest caveat: Bug Validator is currently in beta and 32-bit only. If you were using Function Trace on 64-bit code, 64-bit Bug Validator support is in development.

Starting the migration

If the single-licence appeal of AQTime was important to you, we have suites that cover the same ground.

The Support Suite includes Memory Validator and Performance Validator.

The QA Suite includes Memory Validator, Coverage Validator, and Performance Validator — the three tools that replace AQTime’s core capabilities.

The Developer Suite includes Memory Validator, Coverage Validator, Performance Validator, and Thread Validator for thread analysis and deadlock detection.

All tools are available as fully functional 30-day trials. No feature restrictions during the trial.

If you have questions about specific AQTime workflows and how they map to our tools, contact us directly. We’re happy to walk through your setup.

---

AQTime 8 documentation is available at support.smartbear.com/aqtime/docs/ until the end of June 2026, if you need to reference it during migration.