Serious Cross-Platform for Visual Studio!

Modern C++17 on VS2008-2022

The Clang-based IntelliSense engine fully supports all the C++17 features supported by clang, such as lambdas, variadic templates, automatic type derivation, range-based loops, etc.

The engine never makes a blind guess - it sees the code the way the compiler does and never gets confused by complex templates or GCC-specific features.

Powerful refactoring

The Clang-based IntelliSense supports many powerful and time-saving refactoring features, that are not supported by Visual Studio IntelliSense. VisualGDB can automatically create method bodies and implement entire interfaces, supports the Create-from-Use function familiar to C# developers, will generate initializer lists for constructors and suggest renaming methods, classes and types once you edit the declaration.

Easy Navigation with CodeJumps

Enjoy lightning-fast navigation across large codebases with CodeJumps - clickable labels shown for C/C++ functions, types and fields.

Instantly lookup references, visualize class hierarchies, call trees and lookup method implementations, or even C-style functions assigned to a specific function pointer anywhere in the project.

Powerful Code Explorer

With Code Explorer, you can easily navigate through huge and convoluted code bases.

The Outline view provides highly customizable high-level view of the current file structure. It can show classes, functions, statements, #ifdef blocks, and code groups separated by comments.

The Globals view shows a hierarchical view of all symbols in the solution with instant filtering by type and name.

The Details view allows quickly locating function callers, instances of specific types, functions allocating/deleting a specific type, and much more.

Code Generation with RefactorScript

VisualGDB takes code snippets to a new level with RefactorScript - a powerful mechanism for generating common code patterns: constructors, comparison operators, mock classes, you name it.

Instant previews and a detailed code model makes generating repetitive code a breeze.


Automatic header path repair

Missing include directories are no longer a problem. VisualGDB can automatically scan nearby directories, locate the missing header files and adjust the project settings to get your project to build in seconds.

First-Class Clang-Format Integration

In addition to VisualGDB's own lightweight code formatting engine, it is now fully integrated with clang-format, including seamless smart indent integration and a powerful graphical editor for formatting styles with live preview.

Preprocessor Lens

VisualGDB simplifies understanding of complex code that involves many preprocessor macros by providing the "Preprocess selected lines" command.

The preprocessing result is precise and correctly handles multiple redefined macros.

Code Map for C++ code

VisualGDB adds detailed C/C++ support to Code Map that is normally available only on C#. You can graphically explore relations between classes, methods, variables, fields and types.

The VisualGDB-powered code maps can show inheritance, call hierarchies, overridden methods and relations between code and data.

Advanced "Find References" command

The Clang-based IntelliSense engine uses a heavily optimized database format to quickly find definitions and references even in huge projects like the Linux Kernel.

VisualGDB distinguishes the context of each reference, and allows quickly filtering the references by type or name.

Precise and informative error reporting

The engine takes error messages directly from the clang compiler. It is fully aware of the GNU language extensions and provides much more information:

  • See warnings as well as errors
  • See template instantiation locations

When you open a header file, the new engine automatically detects a source file that is including it and parses the header in the right context, producing accurate error messages and code completion. 

Integration with debugger

VisualGDB automatically expands preprocessor macros in Watch and Auto expressions. The expansion is context-sensitive, so you will always see precise results, even if your macro is redefined in multiple places.

Code Completion support in Watch window makes it easier to find the values you are looking for and eliminates extra typing.