Parasoft Insure++ is being discontinued in June/July 2026. This guide maps Insure++ capabilities to their Software Verify equivalents and describes the workflow differences for each.
See also: Parasoft Insure++ is being discontinued for a summary of what changes and what you gain.
| Insure++ capability | Software Verify replacement | Notes |
|---|---|---|
| Heap memory leak detection | Memory Validator | Direct replacement |
| Use-after-free (deleted pointer) | Memory Validator | Called “deleted-this” in MV; off by default |
| Double-free detection | Memory Validator | Direct replacement |
| Buffer overflow / heap corruption | Memory Validator | Heap-level detection |
| Third-party DLL leak detection | Memory Validator | MV sees leaks in all DLLs |
| Dynamic memory visualisation | Memory Validator | MV displays are more detailed |
| GDI handle leaks | Memory Validator | Insure++ did not cover these — MV adds this |
| Windows kernel handle leaks | Memory Validator | Insure++ did not cover these — MV adds this |
| .NET handle leaks | Memory Validator | Insure++ did not cover these — MV adds this |
| Code coverage | Coverage Validator | Separate product — not bundled with MV |
| Static / compile-time analysis | Not covered by SVL | Use a dedicated static analysis tool |
Insure++ generated its own instrumented build of your source code, which was then compiled by your actual compiler. This required a full recompile and relink of your application for every analysis run. The benefit was deep compile-time visibility — Insure++ could apply static heuristics at parse time in addition to runtime checks.
Without source instrumentation, Insure++ could link against your existing object files to intercept API calls at runtime — detecting leaks and bad references without a recompile, but with less detail than full source instrumentation.
Memory Validator instruments at the binary level, at runtime. There is no recompile, no relink, and no source modification at any stage. You attach to your existing build and run. Enabling additional detection features (such as deleted-this) is a settings change — it does not require rebuilding the application.
Both Insure++ and Memory Validator detect heap memory leaks with full call stack information. Memory Validator tracks every allocation and deallocation across heap, stack, and shared memory, including allocations inside third-party DLLs.
The only leaks Memory Validator does not report are those originating inside Microsoft DLL internals — where the deallocation is handled via an intra-DLL call that cannot be intercepted — and any DLLs the user has explicitly marked to ignore in MV’s settings.
Memory Validator detects both. Use-after-free is called deleted-this in Memory Validator’s terminology. It is off by default because it adds an instrumentation step. Enabling it requires no recompile — it is a settings change. Double-free detection is always active.
Insure++ detected both via source instrumentation, which required a recompile. Memory Validator achieves the same detection at runtime against the existing binary.
Memory Validator detects heap overwrites — writes that corrupt memory adjacent to a heap allocation. Stack-based buffer overflows are handled at the OS and compiler level (stack canaries, /GS flag) rather than by a memory profiler.
Insure++ explicitly supported analysis of memory behaviour inside third-party libraries. Memory Validator does the same — leaks originating inside any DLL your application loads are visible, with the exceptions noted above.
Insure++ tracked heap memory only. It had no coverage of Windows handle types.
Memory Validator tracks:
GDI exhaustion and Windows handle exhaustion are common sources of hard-to-diagnose crashes in long-running Windows applications. These were invisible to Insure++. Memory Validator surfaces them in the same session as heap analysis.
Insure++ included dynamic memory visualisation — graphical display of allocations and deallocations correlated with application runtime.
Memory Validator’s graphical displays cover the same ground with more detail: more dedicated views showing allocation data from different angles, colour coding to convey information at a glance, and richer callstack data per allocation entry.
Insure++ bundled code coverage as part of the product. This is not the case with Memory Validator — code coverage is a separate Software Verify product: Coverage Validator.
Coverage Validator provides line-level and routine-level coverage with hit counts, partial line handling, and multi-run session merging. It supports the same compiler range as Memory Validator.
If code coverage was part of your Insure++ workflow, you will need both products. They are available individually or together as part of a suite.
Insure++ applied static heuristics at source instrumentation time — “hundreds of heuristics” covering type mismatches, incorrect standard library usage, and similar compile-time issues.
Software Verify tools do not include static analysis. For static analysis of C/C++ code, use a dedicated static analysis tool alongside Memory Validator.
| Language | Insure++ | Memory Validator |
|---|---|---|
| Languages | C and C++ only | C, C++, Delphi, and any language with debug info |
| MSVC / Visual C++ | VS 2015, 2017, 2019 only | VC6 through VS 2026 (all versions) |
| GCC / G++ | Not supported on Windows | Supported |
| Clang | Not supported on Windows | Supported |
| Delphi | Not supported | Supported |
| Rust | Not supported | Supported (heap caveat for custom allocators) |
| .NET / managed code | Not supported | Supported |
| Operating System | Insure++ | Memory Validator |
|---|---|---|
| Windows (desktop) | Windows 10 only | Windows XP through Windows 10 and 11 |
| Windows Server | Server 2008, 2012, 2019 only — Server 2022 not supported | All equivalent server versions |
| Windows 11 | Not supported | Supported |
| Windows Server 2022 | Not supported | Supported |
Memory Validator and Coverage Validator are available individually or as part of a suite:
Support Suite — Memory Validator, Performance Validator.
QA Suite — Memory Validator, Coverage Validator, Performance Validator.
Developer Suite — Memory Validator, Coverage Validator, Performance Validator, Thread Validator.
All Software Verify tools are available as fully functional 30-day trials:
If you have questions about how your Insure++ workflow maps to our tools, contact us.