Development Environments & IDEs

Add the Vulkan SDK include directory to your project’s include paths ($(VULKAN_SDK)/Include)

Add the Vulkan SDK library directory to your project’s library paths ($(VULKAN_SDK)/Lib or $(VULKAN_SDK)/Lib32)

Link against vulkan-1.lib

File → Open → CMake…​

Select your CMakeLists.txt file

Right-click on CMakeLists.txt → CMake Settings

Add any additional CMake variables or configuration options

Install RenderDoc

In Visual Studio, go to Debug → Graphics → Start Graphics Debugging

RenderDoc can capture and analyze Vulkan API calls

For NVIDIA GPUs, use NVIDIA Nsight Graphics which integrates directly with Visual Studio

For AMD GPUs, use AMD Radeon GPU Profiler (RGP) through the Radeon Developer Panel

For Intel GPUs, use Intel Graphics Performance Analyzers (GPA)

For cross-vendor profiling, consider VKtracer or GFXReconstruct

C/C++ extension by Microsoft

CMake Tools (if using CMake)

Shader languages support (GLSL, HLSL)

Create a .vscode/settings.json file:

{
    "cmake.configureOnOpen": true,
    "cmake.buildDirectory": "${workspaceFolder}/build",
    "cmake.generator": "Ninja"
}

Install the RenderDoc extension for VS Code

Configure launch tasks to start RenderDoc with your application

Analyze captured frames directly from VS Code

Use RenderDoc for frame capture and analysis

For cross-platform profiling, use VKtracer or GFXReconstruct

For vendor-specific profiling, launch the appropriate tool from the command line or use their VS Code extensions if available

Open your project’s CMakeLists.txt

Configure the Vulkan include and library paths in your CMake configuration

File → Settings → Build, Execution, Deployment → CMake

Add profiles for different build types (Debug, Release, etc.)

Go to Run → Edit Configurations

Add a new configuration for your application

In the Environment Variables section, add VK_LAYER_PATH pointing to your Vulkan SDK layers directory

Enable the Vulkan validation layers in your application

Configure RenderDoc integration by launching your application through RenderDoc

Use RenderDoc for frame capture and analysis

For cross-platform profiling, use VKtracer or GFXReconstruct

For NVIDIA GPUs, configure NVIDIA Nsight Graphics as an external tool

For AMD GPUs, use AMD Radeon GPU Profiler (RGP) through the Radeon Developer Panel

For Intel GPUs, configure Intel Graphics Performance Analyzers (GPA) as an external tool

Go to File → Settings → Tools → External Tools

Add your profiling tools with appropriate command-line arguments

Access them via Tools → External Tools in the menu

Add the Vulkan SDK include directory to your project’s include paths

Add the MoltenVK framework to your project

Link against the necessary libraries

Edit your scheme (Product → Scheme → Edit Scheme)

In the Run section, go to Arguments

Add environment variables for Vulkan validation layers:

VK_LAYER_PATH pointing to your Vulkan SDK layers directory

VK_ICD_FILENAMES pointing to your MoltenVK ICD JSON file

Enable the Vulkan validation layers in your application

Use Xcode’s built-in debugging tools

Consider using RenderDoc (though support on macOS may be limited)

Use Xcode’s built-in Instruments tool (Xcode → Product → Profile)

The Metal System Trace instrument can help analyze GPU performance

The Time Profiler can identify CPU bottlenecks in your Vulkan application

Enable MoltenVK’s performance tracking features

Add the following to your environment variables:

MVK_CONFIG_TRACE_VULKAN_CALLS=1 to log Vulkan API calls

MVK_CONFIG_PERFORMANCE_TRACKING=1 to enable performance tracking

For cross-platform profiling, consider VKtracer which works on macOS

GFXReconstruct can be used to capture and replay Vulkan API calls

Open Android Studio → Tools → SDK Manager

Select the "SDK Tools" tab

Check "NDK (Side by side)" and "CMake"

Click "Apply" to download and install

Create a new Android project with Native C support or add C to an existing project

In your app/build.gradle file, ensure the minimum SDK version supports Vulkan:

android {
    defaultConfig {
        minSdkVersion 24 // Vulkan requires Android 7.0 (API level 24) or higher
        // ...
    }
    // ...
}

The Vulkan headers are included in the Android NDK

In your CMakeLists.txt, add:

# Find the Vulkan package
find_package(Vulkan REQUIRED)

# Include Vulkan headers
include_directories(${VULKAN_INCLUDE_DIRS})

# Link against Vulkan
target_link_libraries(your_native_lib Vulkan::Vulkan)

Set breakpoints in your C++ code

Use the debugger to step through your Vulkan code

Inspect variables and memory

Use Android GPU Inspector (AGI) for GPU profiling and debugging

AGI can be launched directly from Android Studio via Tools → Android → Android GPU Inspector

Capture Vulkan API calls, analyze GPU workloads, and identify performance bottlenecks

Use Android Studio’s built-in System Trace tool (Profiler → System Trace)

Analyze CPU, GPU, and system-level performance

Use Qualcomm Snapdragon Profiler for detailed GPU analysis

Provides Vulkan-specific insights for Adreno GPUs

Ensure the SDK’s bin directory is in your system PATH

Note the location of the SDK for include and library paths

Add $(VULKAN_SDK)/Include or equivalent to your include paths

For platform-specific development, include the appropriate platform headers

Add $(VULKAN_SDK)/Lib or equivalent to your library paths

Link against the appropriate Vulkan library (vulkan-1.lib on Windows, libvulkan.so on Linux, etc.)

Shader compilers (glslangValidator, DXC, slangc)

Validation layer tools

Debugging and profiling tools (RenderDoc, GPU-specific tools)

Most modern IDEs have built-in CMake support or plugins

For IDEs without direct CMake support, you can generate project files:

For Visual Studio: cmake -G "Visual Studio 16 2019" -A x64 -B build .

For Xcode: cmake -G Xcode -B build .

For Makefiles: cmake -G "Unix Makefiles" -B build .

Set environment variables in your IDE’s debug configuration:

VK_LAYER_PATH pointing to your Vulkan SDK layers directory

VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation to enable validation

RenderDoc works with most IDEs and platforms

Configure your IDE to launch your application through RenderDoc

For GPU-specific debugging, use vendor tools as described in the Debugging section

Create custom run configurations or external tool integrations

Set up keyboard shortcuts for common profiling tasks

RenderDoc for frame capture and basic profiling

VKtracer for cross-vendor API tracing

GFXReconstruct for capture and replay

Use vendor-specific tools as described in the Profiling section

Configure your IDE to set the necessary environment variables for these tools

Use glslangValidator for GLSL shaders

Use dxc with the -Zi flag for HLSL shaders to include debug information

Use GL_EXT_debug_printf extension for printf functionality

RenderDoc has excellent support for GLSL shader debugging

Use glslangValidator with -g flag to include debug information

Use the DirectX Shader Compiler (DXC) with debugging flags

Add the -Zi flag to include debug information

Use the -Od flag to disable optimizations for better debugging

HLSL printf requires special extensions as shown in the example above