GlowCode Does Four Things. That Is the Problem.

GlowCode from Electric Software claims to do four things: detect memory and handle leaks, profile performance, measure code coverage, and trace execution. One tool, one licence, four jobs.

That is the Swiss army knife proposition. Every developer has one. They are genuinely useful when you are somewhere without the right tool and you need to get something done. But when you are back at your bench doing real work, you reach for the chef’s knife – the tool built for exactly the job in front of you.

The question with GlowCode is whether a tool built to do four things does any of them as well as a tool built to do one.

Memory and Handle Leak Detection

GlowCode tracks heap allocations and reports leaks for C/C++, C#, and .NET. It includes GDI handle tracking and Win32 handles. It shows you what leaked, where it was allocated, and how much. That is the detection layer, and it works.

The deeper gap is what you can do with that data. GlowCode is a leak reporter. Memory Validator is an analytical platform. Where GlowCode gives you a list of leaks, Memory Validator adds a summary page, multiple statistical views broken down by memory type and size, .NET views by allocation age and generation, a memory hotspot view, and advanced query and search. Watermarks and bookmarks let you mark and compare points within a session. Custom hooking and a developer API let you drive memory analysis from your own test harness or build pipeline. None of that exists in GlowCode.

The second gap is the compiler ceiling. GlowCode’s memory analysis tops out at Visual Studio 2017. Any team building with VS 2019, VS 2022, or VS 2026 is running outside GlowCode’s confirmed support envelope – and that covers seven years of Visual Studio releases. GlowCode is also MSVC-only for memory analysis: no GCC, no Clang, no Delphi, no Rust.

Memory Validator is built to do this one job. It covers the same heap, handle, and .NET managed memory that GlowCode covers, with full mixed-mode support for applications that cross the native/.NET boundary. It supports MSVC VC6 through VS 2026, GCC, Clang, Delphi, C++Builder, Fortran, and Rust – and Windows Services and IIS-hosted applications. It is the chef’s knife for memory and handle analysis.

In a synthetic stress test, Memory Validator monitored 1 billion malloc calls and 1 billion free calls in a single session, completing in 4 hours on an AMD Ryzen 9 7940HS. Applications that allocate heavily are within its operating envelope.

Performance Profiling

GlowCode’s performance profiler uses PDB-based binary instrumentation – the same fundamental approach as Performance Validator – and can profile applications built with VS 2019 and later. Function timing is on by default.

Where it stops short: no line-level timing, no Windows Service profiling, no IIS support. Line timing in Performance Validator is off by default but available when you need timing at the level of individual source lines rather than at function level. For service and IIS profiling, GlowCode has no coverage at all.

Thread Error Detection

GlowCode has no thread error detection capability. Not a weak implementation – no implementation at all.

Thread Validator detects deadlocks, potential deadlocks, lock-order violations, out-of-order critical section acquisitions, and stalled threads in native C++ applications. No recompile required. If your application is multithreaded – and most production Windows applications are – this is a capability outside GlowCode’s scope entirely. The Swiss army knife does not even have a blade for this job.

Code Coverage and Execution Tracing

GlowCode’s features page lists code coverage and execution tracing as capabilities. What they do in practice, how deep the coverage reporting goes is not documented on the website. The evaluation download did not work as of June 2026, so these claims cannot be verified against the product itself.

Coverage Validator is a dedicated tool built for this job, with full documentation and a freely available 30-day trial. Bug Validator is currently in beta.

One Tool or Four

The Swiss army knife has a real use case: when you need something right now and a dedicated tool is not at hand. GlowCode’s single-licence model is genuinely simpler if your codebase is within its supported envelope and you are not doing deep analysis in any of the four areas.

But if you are investigating a real memory leak in a VS 2022 application – the kind that shows up as instability after 48 hours of uptime in a Windows Service – GlowCode cannot help. The compiler ceiling, the absence of analytical depth, and the lack of service profiling combine against exactly the scenario where a proper tool is most needed.

Software Verify tools are bought separately, one per job. That separation is the point – each tool exists to do one thing thoroughly, without making trade-offs for the demands of three others.

The dedicated tools are available and ready to evaluate. Coverage Validator, Memory Validator, Performance Validator, and Thread Validator are available as 30-day trials – no instrumented build required, no project changes, attach to the binary you actually ship. Bug Validator is currently in beta.