VisualGDB

Serious Cross-Platform for Visual Studio!

1000+ modern devices. One IDE.

VisualGDB automatically installs all necessary tools and code libraries to get your first project working with just a few mouse clicks. It supports STM32, Freescale Kinetis, NXP LPC, TIVA, MSP430, ESP8266 and many other devices.

Simply select your device in the wizard, connect the debug probe and you can start stepping through your first project.

Advanced Arduino Project Subsystem

VisualGDB includes streamlined support for Arduino projects. Getting the detailed project structure directly from the Arduino build tools, VisualGDB provides detailed an accurate project view in Solution Explorer, Clang-based IntelliSense fully aware of the generated Arduino function prototypes and convenient GUI for managing libraries, platforms and debugger settings.

VisualGDB comes with out-of-the-box support for ESP32 Arduino boards, making it easier to utilize the Arduino libraries in your designs.

Static Stack Analysis

VisualGDB comes with a powerful static stack usage analyzer for your embedded projects. It automatically discovers function calls and uses diassembly analysis to compute the worst-case stack utilization in each function for ARM targets.

The low-level stack analysis is performed by our open-source stack analyzer plugin that could be easily modified to take implicit project-specific relations between functions into account.

Easy compiler configuration

VisualGDB provides a graphical interface for configuring most commonly used settings for the devices. You select the settings and VisualGDB handles compiler flags, Makefiles and linker scripts.

You can build VisualGDB projects on machines without VisualGDB using our free toolchains.

Powerful GNU tools streamlined

VisualGDB integrates powerful debugging tools like OpenOCD into your debugging flow. No need to read manpages, configure scripts and struggle with installing correct drivers. Most common setups are automatically detected and configured once you plug in your debug probe into a USB port. VisualGDB will distinguish between different instances of debug probes and automatically patch OpenOCD scripts when needed.

We also support Segger J-Link debugger and many other debug probes.

Easy project importing

VisualGDB comes with plugins for automatically importing projects from most popular IDEs and project generators. Simply point a an existing project and get it converted to a Visual Studio project in no time.

The project importing plugins are open-source and the SDK is documented, so you can easily customize the plugins for your needs, or add support for custom project formats and build systems.

Real-time Watch and Dynamic Analysis

VisualGDB make it easy to analyze real-time behavior of your program.

Measure precise timings of function calls, visualize various FreeRTOS events and save the collected data to compare it with the future runs.

Plot custom events with the custom real-time watch API.

Instrument your code to check stack bounds on each function call with just one click.

Embedded Integration Tests

VisualGDB comes with an intuitive mechanism to verify the critical parts of your embedded program without adding any extra code to it. Simply run your program in debugger, modify its behavior by setting next statements and editing variables and VisualGDB will record this and let you automatically re-run it later and check against the specified constraints. Easily check how your firmware reacts to errors, verify the timing of the critical code parts, check that the interrupt handlers get invoked in time.

 

Embedded Chronometer

VisualGDB features the easiest way ever to keep your program's timing in check - chronometer. Once enabled, it will automatically record the timing between various debug events like breakpoints and steps, so you can see how fast your code performs without starting a heavy profiling session.

The chronometer includes out-of-the-box support for ARM Cortex cycle counters and can be easily extended to use any other time counting peripheral on any embedded target.

Embedded-friendly Memory View

VisualGDB includes an advanced Memory view that is especially optimized for embedded projects. You can view the memory contents while the target is running, add data breakpoints and quickly highlight the bounds of global variables, functions and stack frames.

The new memory view also supports loading/saving memory contents and is optimized for speed.

Live Variables and Visual Watch

Make your embedded debugging easier by viewing and visualizing variable values without stopping your program.

Understand the contents of large arrays faster by plotting them with Visual Watch.

Set break conditions for Visual Watch and have your program stopped when variables reach critical values.

Powerful Embedded Profiler

VisualGDB includes a powerful mechanism for analyzing performance of your embedded projects. Automatically instrument your code to see how much time each function takes or take non-intrusive stack samples to determine the most frequently invoked code. All with just a few mouse clicks.

Read our embedded profiling tutorials to learn more about performance analysis.

Embedded-friendly IntelliSense

VisualGDB includes a Clang-based IntelliSense engine that is fully compatible with GCC-specific language extensions that is often used in embedded code. Unlike the native Visual Studio IntelliSense, it does not get confused by non-standard language extensions. It also supports advanced refactoring and C++ Code Map.

Read more about Clang-based IntelliSense.

Intuitive hardware register viewer

VisualGDB includes an intuitive viewer for peripheral registers.

Instant search, favourite registers and configurable view make it very easy to understand what's happening to the hardware.

VisualGDB comes with register definitions for STM32, Freescale Kinetis, NXP LPC, and many more common platforms and the flexible XML format allows defining register layout for custom devices.

Embedded Memory Explorer

Quickly analyze the structure of your firmware's memory footprint with the Embedded Memory Explorer.

Optional file-based and section-based grouping allows quickly getting an overview of memory utilization.

Double-click navigation makes it easier to browse the source code and understand what makes your functions large.