Mali Graphics Debugger for Vulkan, OpenGL ES, EGL & OpenCL

Mali Graphics Debugger

Vulkan, OpenGL ES, EGL, and OpenCL API Trace and Debug Tool

The Mali Graphics Debugger allows developers to trace Vulkan (1.0), OpenGL ES (1.x, 2.x, and 3.x), EGL (1.4), and OpenCL (1.x) API calls in their application and understand frame-by-frame the effect on the application to help identify possible issues.

Android and Linux ARM based target platforms are currently supported and everything to get up and running within a matter of moments is provided in the installer package.


  • Draw-call by Draw-call stepping
    To identify draw call related issues, redundant draw calls and other opportunities to optimize
  • Texture View
    Visualize an application’s texture usage, to identify opportunities to compress textures or change formats.
  • Shader Statistics
    Understand which vertex and fragment shaders are the most expensive with cycle count reporting
  • Vertex Attribute / Uniform View
    See vertex data and index buffers
  • State View
    Full visibility of graphics state and tracking of state changes
  • Dynamic Optimization Advice
    Highlighting of common API misuse and dynamic performance improvement advice

See more features here

Optimize your mobile game with ARM tools

How can you detect where the performance bottlenecks are in your code? Try utilizing API analysis to debug OpenGL ES graphics, optimize performance of the gaming application and improve the user’s visual experience. An introduction to the tools and skills needed to conduct valuable profiling and debugging on your application.

Optimize your mobile game with ARM tools


More features:

Trace API calls

Trace OpenGL ES, EGL, OpenCL API calls with arguments, time, process ID, and thread ID.

  • Full trace from the start
  • Automatic check for GL errors
  • Search capabilities

graphics debugger

Outline View

Quick access to key graphics events.

  • Frames
  • Render targets
  • Draw calls

Investigate at frame level.

  • Find what draw calls have higher geometry impact

Jump between the outline view and the trace view seamlessly.

graphics debugger

Target State Debug

Shows the current state of the API at any point of the trace.

  • Every time a new API call is selected in the trace the state is updated
  • Useful to debug problems and understand causes for performance issues

Discover when and how a certain state was changed.


Trace Statistics and Analysis

High level statistics about the trace.

  • Per frame
  • Per draw call

Analyze the trace to find common issues.

  • Performance warnings
  • API misuse
  • Highlight API calls causing a problem in the trace view.

graphics debugger

Uniforms and Vertex Attributes for each draw call

When a draw call is selected, all the associated data is available:


  • Show uniform values, including samplers, matrices and arrays

Vertex Attributes

  • Show all the vertex attributes, their name and their position

graphics debuggerfeature-attributes

All the heavy assets are available for debugging, including data buffers and textures


  • Client and server side buffers are captured every time they change
  • See how each API call affects them


  • All the textures being uploaded are captured at native resolution
  • Check their size, format and type

graphics debugger

Shaders reports and statistics

All the shaders being used by the application are reported.

Each shader is compiled with the Mali Offline Compiler and is statically analyzed to display:

  • number of instruction for each GPU pipeline, number of work registers and uniform registers

Additionally, for each draw call MGD knows how many times that shader has been executed (i.e. the number of vertices) and overall statistics are calculated.

graphics debugger

Frame capture and analysis

Frames can be fully captured to analyze the effect of each draw call.

  • A native resolution snapshot of each framebuffer is captured after every draw call
  • The capture happens on target, so target dependent bugs or precision issues can be investigated

All the images can be exported and analyzed separately.

graphics debugger

Alternative drawing modes

Different drawing modes can be forced and used both for live rendering and frame captures.

Native mode

  • Frames are rendered with the original shaders

Overdraw mode

  • Highlights where overdraw happens (i.e. objects are drawn on the top of each other)

Shader map mode

  • Native shaders are replaced with different solid colors

Fragment count mode

  • All the fragments that are processed by each frame are counted

graphics debugger

(Windows/Linux/Mac OS X)

  • Support for OpenGL ESSL 3.2 shaders
  • Professional Edition feature User Scripting has now been added
  • Various bug fixes

Release Notes

MGD now supports user defined application analysis using Python scripts. Using the new Scripting
View you can access all of the information MGD has gathered about your application and perform
advanced analysis.

We’ve combined normal Python 2.7 syntax and standard libraries with the MGD data model so
you can easily extract any information that the MGD GUI doesn’t currently provide, and obviously
because it’s Python you can write your results to a file or print them to the console. Your scripts also
have the ability to add bookmarks to the trace (which are saved with the trace) so you can easily
share your results with others.

  •  Vulkan frame capture now works with depth and stencil attachments as well as supporting transient attachments and multiple subpasses
  • MGD now supports “Full trace replay”
  • Vulkan Linux Support
  • Moved to new version of the Vulkan Loader for Android

Release Notes

Linux support for Vulkan has been added to Mali Graphics Debugger, we have also updated the Android Vulkan loader to a newer version. This means that you can now profile Vulkan on even more devices than before, helping you to optimize all of your Vulkan content.

We have also greatly enhanced the Frame capture feature. Now you can capture depth and stencil attachments. In addition we’ve added support for transient attachments and multiple sub passes, making Mali Graphics Debugger your first and only stop when it comes to Vulkan-related analysis and debugging.

The first professional only edition feature has been completed and it takes the form of full trace replay. This gives DS-5 Development Studio users the ability to replay their trace back on the same target. This can be useful if you want to run the same content on your device again for further analysis.

  • Completely redesigned Assets View.
  • Added support for texture parameters, texture layers and sampler parameters.
  • Command buffer state and vertex buffer bindings for Vulkan.
  • Added perspectives to only show the information relevant to your chosen API

Release Notes:

The Assets View has been completely redesigned from the ground up to allow you to explore all the assets in your application more efficiently. For example, you can now look at a desired shader and explore the program that this shader was attached to.

There have also been some new features added to the Assets View, including support for:

  • OpenGL ES
    • Texture parameters
    • Texture layers and levels
    • Sampler parameters
    • Framebuffer attachment details
  • Vulkan
    • Command buffer state
    • Vertex buffers bindings

There are now individual perspectives for OpenGL ES, Vulkan and OpenCL. This means that views are now only displayed if they are relevant to the API you are using. For example, the Shaders View is not displayed when the OpenCL perspective is active since it’s irrelevant in an OpenCL context.

However, the feature goes further than that. If you don’t find some of the information MGD shows you relevant for the task at hand, you can now remove it and then create a new custom perspective only showing the data that you are interested in. You can then switch to your new custom perspective any time you like.

  • MGD can now track the contents of Vulkan memory buffers.
  • We’ve improved the detection of VR applications in MGD, so applications built using the latest versions of popular VR frameworks and game engines will work more reliably in MGD.
  • The Framebuffers View now allows you to easily visualize if each attachment is enabled or disabled.
  • Support for the following texture formats have been added to the Framebuffers View: R11F_G11F_B10F, RGBA16F, RG16F, R32F and R16F
  • Added Frame Capture for Vulkan
  • Added property tracking for a variety of different Vulkan assets.
  • Numerous bug fixes
  •  Non-root support added for Android 6.0
  •  The Geometry View now has mouse controls for panning the camera
  •  Various bug fixes
  • Filmstrip mode now supports Vulkan applications
  • You can now start tracing an OpenGL ES application after it has started
  • You can now easily jump to a particular function/frame

Release Notes:

This is a minor release following the 3.4.1 release of the tool. It adds the features and fixes the issues listed below:

  • Filmstrip mode now supports Vulkan applications. Toggle the filmstrip mode on to see a thumbnail view of what was rendered for each frame in the Trace Outline View.
  • You can now start tracing an OpenGL ES application after it has started and MGD will recover all of the OpenGL ES and EGL state from the target system at that point. This means you can run your application at full speed up to the point you want to investigate, connect MGD, and start debugging.
  • You can now easily jump to a particular function/frame using the “Go to function/frame (Ctrl+G)” option.
  • Vulkan support has been added
  • VR Support has been added
  • Much improved Render Dependencies View

Release Notes:

Vulkan is the new graphics API by Khronos and represents a new direction for mobile application development. Vulkan support has been added to this release of MGD and has the following features:

  • Full trace of all of the Vulkan API. Allowing you to see what Vulkan calls your application makes and in what order
  • Frame delimitation so that you can see what function calls made a particular Frame.

Virtual Reality (VR) is a very hot topic but as it is still a new technology there has been very little support from tools. This is now changed with the new version of MGD and here are some of the following features that are supported:

  • MGD correctly detects the end of a frame in VR applications when they don’t use eglSwapBuffers
  • Frame capture (with all the supported modes) works correctly for VR applications. Capturing will now continue until all render passes started during a frame have been completed
  • VR applications typically use more than one thread and EGL context to do their rendering. Different EGL contexts are now color coded in the Trace, Trace Outline, and Timeline views to make it more obvious when this is happening

MGD’s render pass dependency analysis has been improved to support render buffer targets as well as glBlitFramebuffer and glClear, allowing you to accurately track many more dependency scenarios in your application.

  • Much improved OpenCL support
  • A new Render Pass Dependencies View
  • Ability to visualize the geometry used by each draw call.

Release Notes:

MGD has had a massive overhaul in regards to its OpenCL support in V3.3. Some of the highlights include:

  • MGD now supports OpenCL 1.2 functions.
  • ‘Interesting’ OpenCL functions (e.g. clEnqueueNDRangeKernel) are now shown in the Trace Outline View. These functions are also marked with relevant information such as the command queue they were issued to.
  • MGD now detects whether OpenCL calls are blocking or not based on the function and its parameters. Blocking calls force the CPU and GPU to synchronize where it might not strictly be necessary, which can result in a reduction in performance. This information is shown in the Trace Outline View.
  • MGD now supports OpenCL function errors in the same way as OpenGL ES function errors. For every OpenCL function that can return an error (through a return value or an output parameter), MGD will check the error value and highlight problems in the Trace Analysis View and the Trace View. Error checking is performed on output parameters regardless of whether the application passed in a valid pointer, so no application modification is necessary.
  • Better tracking of OpenCL kernels and programs. MGD now correctly follows the life cycle of kernel and program objects and supports the related OpenCL 1.2 calls.

OpenCL was not the only focus on this release, it is now possible to view the geometry used by each draw call. The new Geometry Tab in the Vertices View uses the draw call parameters and shader attribute data to render a wireframe view of the geometry on the host machine. The geometry can then be exported to .obj format. This view doesn’t require any additional data from the target so it doesn’t reduce tracing speed. As a result it also works with older traces.

The final major addition is the Render Pass Dependencies View. This view tracks frame buffer attachments to allow you to quickly see which render passes each frame depends on.

  • Streamline annotation support
  • Further UI performance improvements.
  • New memory reporting feature

Release Notes:

MGD can now automatically add Streamline annotations to your code for you. This frees up more of your time to debug and optimize your application. Annotations can be used to show the following in Streamline:

  • Frames per second data.
  • Number of vertices drawn by each frame.
  • A new Mali Graphics Debugger Activity View.

Improvements to the performance of the UI have been one of the main focuses of the release. With this focus we have been able to improve the views listed below:

  • Textures view: This has been redesigned from the ground up and is now substantially faster than the previous version.
  • Buffers view: Not only has the performance of this view improved but it is now possible to search for the last binding of the buffer. This allows you to filter by buffers used for different purposes. For example: Show all of the buffers that are used for Vertex Buffer Objects (VBOs). You can also now get the size of selected buffers, so you can see how much data you are actually using.
  • Vertex view: A new view that replaces the old Vertex Attributes view. Not only does this view provide all of the functionality from the Vertex Attributes view but it also presents the indices passed to each draw call. With this information you can calculate the triangles that were actually drawn per draw call.

A completely new feature has also been added to MGD in this release. It is now possible to get the memory allocated by the Mali driver for your application. MGD can now give you per frame memory information and explain to you what the memory was used for. An example of this would be memory that was used storing textures, or memory that was used in storing your application’s buffers.

  • Support for Android 6.0 (Marshmallow)
  • New Automated Trace feature which allows you to automatically run MGD commands on specified frames.
  • Histograms for overdraw and shader map data to allow you to easy identify heavy overdraw and most used shaders per framebuffer.
  • Existing statistics (number of verticies, number of draw calls, etc.) can now be viewed in graph form.
  • The Target State View filter now accepts regular expressions allowing for construction of more complex ‘watch-lists’.
  • Support for tracing OpenGL ES 3.2 (including support for Tessellation and Geometry shaders).