## Debuggers

### Debugging with validation layer

Vulkan is designed for high performance and low driver overhead. To achieve
this, it includes only very limited error checking and debugging capabilities
by default. If you do something wrong, the driver will often crash instead of
returning an error code, or even worse, it will appear to work on your graphics
card but completely fail on others.

To enable extensive checks during your development, Vulkan provides validation
layers, which are pieces of code that can be inserted between the API and the
graphics driver to do things like running extra checks on function parameters
and tracking memory management problems. You can enable validation layers during
development and completely disable them when releasing your application with
zero overhead.

Validation layers can be written by anyone, but Khronos provides a single
standard set called `VK_LAYER_KHRONOS_validation`. Check out
[Vulkan validation layers on Android](https://developer.android.com/ndk/guides/graphics/validation-layer)
from the Android NDK page to enable the validation layer in your application.

### RenderDoc

RenderDoc is another powerful open source tool that lets you capture a frame for
inspection and analysis. It is a very powerful tool that has been used by
graphics programmers to debug their rendered scenes. It supports Vulkan on
Android well although your application has to be set as
[debuggable](https://developer.android.com/guide/topics/manifest/application-element#debug)
for it to work.

For information on how to set up and use it on your Android application, check
out [How do I use RenderDoc on Android](https://renderdoc.org/docs/how/how_android_capture.html).

## Capture / Replay Libraries

### GFXReconstruct

GFXReconstruct is an open source project that provides tools to capture and
replay graphics API calls executed by an application. The recorded trace can
later be replayed to reconstruct the graphics-specific behavior of the captured
application. One of the main advantages of GFXReconstruct is that it lets you
use it on your released application (when you have turned off
[android:debuggable](https://developer.android.com/guide/topics/manifest/application-element#debug)).

For more information, visit the project
[repository](https://github.com/LunarG/gfxreconstruct).
Setting up and usage information for Vulkan on Android is available in
[GFXReconstruct API Capture and Replay for Android](https://github.com/LunarG/gfxreconstruct/blob/dev/USAGE_android.md).

Note that the trace files are not portable, meaning that you cannot capture the
file on one device and replay it on another device (with different OS version,
chipsets, or even driver version).

## Profilers

### Android GPU Inspector (AGI)

Android GPU Inspector (AGI) is a graphics profiler built for Android that
includes a [System Profile](https://developer.android.com/agi/sys-trace/system-profiler) and a
[Frame Profiler](https://developer.android.com/agi/frame-trace/frame-profiler). It provides high-level
profiling information that allows you to understand your game's performance
profile and identify bottlenecks.

To download AGI and learn how to use it, check out the
[Android GPU Inspector](https://gpuinspector.dev/) website.

### Android Studio Profiler

Android Studio Profiler is a useful tool for profiling your app performance.
However, it is not specifically geared towards graphics profiling. It consists
of CPU Profiler, Memory Profiler, Network Profiler, Energy Profiler, Power
Profiler and Event Monitor.

For more information on how to set up and use Android Studio Profiler, check out
[Profile your app performance](https://developer.android.com/studio/profile) section.

## OEM Profilers

The tools in this section are OEM specific and may not work on devices running
on other chips.

### ARM Performance Studio for Mobile

[Arm Performance Studio for Mobile](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio%20for%20Mobile)
is the new name for Arm Mobile Studio. It is a suite of tools that includes
[Graphics Analyzer](https://developer.arm.com/tools-and-software/graphics-and-gaming/arm-mobile-studio/components/graphics-analyzer)
and [Frame Advisor](https://developer.arm.com/Tools%20and%20Software/Frame%20Advisor)
to help you identify and fix performance problems on ARM GPUs.

For more information, check out [Arm Performance Studio for Mobile](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio%20for%20Mobile)
website.

### ARM PerfDoc for Mali GPUs

[PerfDoc](https://github.com/ARM-software/perfdoc) is a Vulkan layer developed
to validate applications against ARM's Mali GPU best practices. It has since
been merged into VK_LAYER_KHRONOS_validation and is essentially part of the
standard Vulkan validation layers.

For information on how to use it, check out [Debugging with validation layer](https://developer.android.com/games/develop/vulkan/tools-and-advanced-features#debugging-with-validation-layer)
section.

### Qualcomm Snapdragon Profiler

Qualcomm Snapdragon Profiler is a profiling software developed by Qualcomm for
application developers to analyze CPU, GPU, DSP, memory, power, thermal and
network performance to identify bottlenecks on their chipsets.

For more information, check out
[Snapdragon Profiler on Qualcomm Developer Network](https://developer.qualcomm.com/software/snapdragon-profiler).

### Samsung GPUWatch

Samsung's [GPUWatch](https://developer.samsung.com/galaxy-gamedev/gpuwatch.html)
is a tool for observing GPU activity on Samsung devices. Unlike the other tools,
you can use this tool directly from your mobile device, so it is very handy to
check your application performance immediately even when you do not have access
to another host computer.

For more information on how to enable it, check out the [User Guide](https://developer.samsung.com/galaxy-gamedev/gpuwatch-userguide/gpuwatch_v2.html).

### PVRTune

Imagination Technologies'
[PVRTune](https://developer.imaginationtech.com/solutions/pvrtune/) enables
developers to profile applications on PowerVR hardware in real-time with a wide
array of counters and metrics. It also allows the session to be saved for
further low-level analysis and to detect performance bottlenecks.

For more information on how to use PVRTune, check out the [Manual](https://docs.imgtec.com/tools-manuals/pvrtune-manual/html/pvrtune-manual/topics/introduction.html).

## Migration Tools

### Converting shaders from GLSL to SPIR-V

The Vulkan API expects shader programs to be provided in the SPIR-V binary
intermediate format. This convention is different from OpenGL ES, where you
could submit source code written in the [OpenGL Shading Language (GLSL)](https://www.khronos.org/opengl/wiki/OpenGL_Shading_Language)
as text strings.

NDK r12 and later includes a runtime library for compiling GLSL shaders into
SPIR-V which can be used by Vulkan. The [shaderc](https://github.com/google/shaderc)
compiler can be used to compile shader programs written in GLSL into SPIR-V.
If your game uses HLSL, the [DirectXShaderCompiler](https://github.com/microsoft/DirectXShaderCompiler)
supports SPIR-V output.

Typically, you will need to compile shader programs offline as part of the asset
build process for your game and include the SPIR-V modules as part of your
runtime assets.

For more information on the shader compilation process for your Vulkan
application, check out [Vulkan shader compilers on Android](https://developer.android.com/ndk/guides/graphics/shader-compilers)
in the Android NDK section.

## Advanced Features

### Integrate Android Frame Pacing into your Vulkan renderer

Android Frame Pacing library (also known as Swappy) helps Vulkan games achieve
smooth rendering and correct pacing to keep the game rendering loop in sync with
the OS's display subsystem and the underlying display hardware.

Correct pacing eliminates visual artifacts known as tearing, optimize power
consumption through synchronization between display refreshes and frame
presentation, and also eliminate janks by stabilizing frame rate. To learn more
about the importance of frame pacing, check out the
[Frame Pacing Library](https://developer.android.com/games/sdk/frame-pacing) section of the AGDK.

For more information on how to integrate frame pacing into your game, check out
[Integrate Android Frame Pacing into your Vulkan renderer](https://developer.android.com/games/sdk/frame-pacing/vulkan).

### Handle device orientation with Vulkan pre-rotation

Surface rotation handling outside of the application may not be free. Even on
some higher end devices with dedicated Display Processing Unit (DPU), there will
still likely be a measurable performance penalty to pay and the impact will
depend whether your application is CPU bound or GPU bound.

Vulkan provides developers with the power to specify much more information to
devices about the rendering state compared to OpenGL. One such information is
**device orientation** and its relationship to **render surface orientation**.
This capability lets you implement pre-rotation to get the most out of Vulkan on
Android.

For more information on how to efficiently handle device rotation on your
Vulkan application, check out [Handle device orientation with Vulkan pre-rotation](https://developer.android.com/games/optimize/vulkan-prerotation)
and the accompanying
[demo application](https://github.com/google/vulkan-pre-rotation-demo).

### Optimize with reduced precision

The numerical format of graphics data and shader calculations can have a
significant impact on the performance of your game. The majority of calculations
and data in modern 3D graphics are using floating point numbers. Vulkan on
Android uses floating point numbers that are 32 or 16 bits in size. A 32-bit
floating point number is commonly referred to as single precision or full
precision. Although 64-bit floating point type is defined in Vulkan, it is not
commonly supported and its use is not recommended.

Check out
[Optimize with reduced precision](https://developer.android.com/games/optimize/vulkan-reduced-precision)
for information on how to optimize your Vulkan application for best performance
on your arithmetics.