WEBGL_debug_renderer_info extension survey results

Feb. 10, 2016

This post discusses the WebGL extension WEBGL_debug_render_info.

I will present the results of a survey I collected during the course of last week about this extension and briefly give an overview of the history and use of the extension.



There are several milestones in the history of this extension worth mentioning:

  • 2011, October: Initial revision of the extension.
  • 2012, March: Google Chrome on desktops enables the extension for 5% of its users.
  • 2013, May: Extension is ratified by the Khronos Board of Promoters. There is no more ratification tier above this one.
  • 2014, January: Google Chrome on desktops and mobiles enables the extension for all of its users.
  • 2014, July: Internet Explorer enables the extension for all of its users.
  • 2014, July: Firefox (possibly) enables the extension for 1% of its users.

Get the data

This is a short example of how to obtain the vendor and gpu information from WebGL:

var gl = canvas.getContext('webgl');
var extension = gl.getExtension('WEBGL_debug_renderer_info');
if(extension != null){
    var gpu = extension.UNMASKED_RENDERER_WEBGL;
    var vendor = extension.UNMASKED_VENDOR_WEBGL;
    var gpu = null;
    var vendor = null;

Using the data

Good uses of this data include:

  • Estimating the available VRam.
  • Logging and estimating the performance level for your use-case.
  • Implement different rendering paths that account for performance differences of GPUs.
  • Track hardware evolution of your user-base for planning of future implementation efforts.
  • Identify and track GPU related issues and their impact.
  • Filing bug tickets with Browser vendors about issues and stating the hardware they occur on and how often you see the hardware.
  • Allocating engineering time to VRam/performance/bugs effectively by their impact on your users.

How does the data look like?

The returned data is unstructured and format may vary between browser vendors, OS and driver. Below is an excerpt of some renderer entries from yesterdays WebGL Stats hits:

ANGLE (Intel(R) HD Graphics Family Direct3D9Ex vs_3_0 ps_3_0)
Microsoft Basic Render Driver
ANGLE (NVIDIA GeForce GTX 950 Direct3D9Ex vs_3_0 ps_3_0)
ANGLE (Intel(R) HD Graphics 4600 Direct3D11 vs_5_0 ps_5_0)
ANGLE (Intel(R) HD Graphics Family Direct3D11 vs_5_0 ps_5_0)
PowerVR SGX 544MP
Adreno (TM) 405
Intel(R) HD Graphics 4600
Adreno (TM) 330
ANGLE (Intel(R) HD Graphics 4600 Direct3D11 vs_5_0 ps_5_0)
ANGLE (NVIDIA GeForce GTX 960 Direct3D11 vs_5_0 ps_5_0)
ANGLE (Intel(R) HD Graphics Family Direct3D11 vs_5_0 ps_5_0)
ANGLE (Intel(R) HD Graphics 5300 Direct3D11 vs_5_0 ps_5_0)
ANGLE (Intel(R) HD Graphics 4000 Direct3D11 vs_5_0 ps_5_0)
Intel(R) HD Graphics 4400
ANGLE (ATI Radeon HD 3450 Direct3D9Ex vs_3_0 ps_3_0)
ANGLE (Intel(R) HD Graphics 4000 Direct3D11 vs_5_0 ps_5_0)
ANGLE (Intel(R) HD Graphics 4600 Direct3D11 vs_5_0 ps_5_0)
Microsoft Basic Render Driver

Support for the extension

The statistics from January 2016 on WebGL Stats show an overall support for this extension of 75.6%.

Here is an overview by platform:

Below is the browser implementation matrix:

Google Chrome Yes
Internet Explorer Yes
Firefox No
Safari No
Microsoft Edge Yes


If this data is useful for you, but a Browser does not implement the extension, you can fall back to several alternatives.

Version and Renderer parameters

Safari, older versions of IE11 and other browsers might expose this information in some of the standard WebGL parameters. Firefox does not expose any information.

var gl = canvas.getContext('webgl');
var renderer = gl.getParameter(gl.RENDERER);
var version = gl.getParameter(gl.VERSION);
var glsl = gl.getParameter(gl.SHADING_LANGUAGE_VERSION);

You can record and analyze this data and see if it contains any useful clues.


Sometimes the user agent might indicate a fixed platform (such as Xbox, iOS etc.) where the GPU is known. In those cases you can correlate the user-agent platform information to GPU.

Other parameters

WebGL allows you to query a host of parameters from the implementation. WebGL 1.0 supports 28 parameters plus the parameter from some extensions. In WebGL 2.0 there will be 55 parameters.

These parameters might help you to get an idea how many users come with a similar GPU, but correllation between underlying hardware and parameters is always a bit fuzzy.


I am collecting a survey on the use of the extension. At the time of writing I received 27 replies. You can send me your responses and affiliation to pyalot@gmail.com and I will update the blog entry.

Q1: Do you currently use this extension?

Responses from this question are straightforward.

Q2: Do you plan on using the extension in the future?

Responses to this question are mostly simple, with some exceptions.

Some reservations were noted:

„Hadn't planned on it as we try to run code that works across all devices as equally as possible.“
Mike Bond, Box Inc.
„ I really do not want to vary our WebGL features by GPU model/vendor. I want to vary features based only on WebGL extensions and feature levels. I do not want to have to work around bugs on a vendor and model level.“
Ben Houston, Clara.io
„No, I do not plan to use this extension in the future. GPU vendors should provide webgl compliant drivers. ...
Xavier Bourry, WebGL Academy
„hopefully not, but probably: yes“
Frederik Maucksch, CTO at xymatic GmbH, DELIGHTengine

Q3: Should Browsers implement the extension?

Reservations noted:

„Yes, although possibly disabled in private browsing modes to reduce fingerprinting“
Ashley Gullen, Scierra Ltd
„It seems like it might be useful but also a potential privacy concern. As drivers become more mature and WebGL adoption grows, I expect the need to know the specific hardware that you're running on will decrease. So far, I hadn't had a real desire to use this. Most devices that have caused me problems have been blacklisted by Chrome and Firefox anyway.“
Mike Bond, Box Inc.
„ I do not really need it. If others have strong opinions feel free to add it but I would prefer to avoid its use.“
Ben Houston, Clara.io
„ No I do not think. And there are so many nice features and extensions which should be great to add to WebGL ! For example GL_ARB_gpu_shader_fp64, it would be great for my neural network :)“
Xavier Bourry, WebGL Academy

Q4: Can you briefly describe your use (or planned use)?

The replies from this question are varied and I categorized them:

  • Diagnostics (debugging): Using the information to assess the impact of issues and test them.
  • Workarounds: Using the information to work around bugs.
  • Analytics: Getting a statistical insight into what hardware users have.
  • Performance: Targeting different render paths to account for performance differences.
  • Vram: Adjusting ram consumption based on the information to avoid context loss etc.
„To see on which card my game has problems on.“
Small Indie game developer Istrolid
„Easy bug reporting, especially by non-savvy users.“
Steve Wittens, Independent dev with very little hardware variety for testing, acko.net
„1) Aggregate usage data per graphics driver and cross correlate against performance issues and bugs. 2) Collect data for problem troubleshooting for customer support“
Tony Parisi, VP of Web and Open Technologies at Wevr
„We use WEBGL_debug_renderer_info together with UA string to estimate device performance and available VRAM. Based on this information we enable or disable computation expensive features and adapt texture sizes in order to optimize performance and reduce battery consumption.“
Tomas Polach, Spin-Off ETH (product: online 3d indoor maps) Archilogic
„Our middleware reveals this data to users for diagnostic purposes. Of particular interest is determining which hardware renderer is in use on dual-GPU laptops. The string returned by WEBGL_debug_renderer serves as the authority on which GPU is in use, verifying that any changed settings have taken effect.“
Ashley Gullen, Scirra Ltd
„When we find bugs in driver/browser we use that to code workaround or to enable/disable the feature.“
Cedric Pinson, Co-Founder & CTO, Sketchfab
„Currently we use this extension to disable features for unsupported devices.“
Yuri Kovelenov, Blend4Web
„Debugging and allowing developers to communicate better with users of apps, as well as analytics to understand the audience.“
David Evans, PlayCanvas
„We use the data to discover GPU-specific issues. Sometimes this leads to a work-around that fixes the issue for the particular GPU (without regressing functionality for other GPUs). Even if it does not, it is useful to have the information in order to communicate known issues to users. We've occasionally found that issues can be resolved by prompting a user to upgrade their driver on problematic GPUs. It could be useful to have driver version information with the GPU data, as this would help pinpoint where the problem lies in such cases.“
Evan Nowak, Onshape
„Off the top of my head, the only thing I would use it for is to detect buggy/broken WebGL implementations so I could disable known broken functionality.“
Luke Groeninger, dghost.net
„Diagnosing broken-driver-related rendering issues, preemptively moving low-performing clients to fallback renderers.“
Austin Appleby, WebGL dev on Google Maps
„We use the returns of the function as one input for server based client/capacity class matching. This is the uses to control e.g. the memory management setting automatically.“
Johannes Behr, instant3Dhub
„Primarily error reporting. It would be useful to know a user's GPU when troubleshooting reported problems. Many of our users are non-technical, so it would be extremely helpful to have the system able to automatically report that information.“
Tarek Sherif, 3D Software Engineer, BioDigital
„I’m using it to detect the GFX driver for debugging purpose. Also really useful for IE/Edge to detect when the engine switch to software rendering“
David Catuhe, Working for Microsoft as principal Program Manager, BabylonJS
„Debugging issues specific to certain hardware locally as well as sending debug info up to vendors to fix potential issues on their end.“
Felix Palmer, Procedural Ltd
„Currently using to detect certain combinations of browser/webgl renderer to implement workarounds for bugs in those implementations. Ideally we wouldn't need this if all renderers etc were fully standardised and worked. It can be useful mainly for identification of client setup to reproduce bugs for debugging purposes.“
James Austin, ga.me, Turbulenz
„we use it to degrade certain features in case of webgl implementation bugs, driver bugs and or hardware bugs, that said, we'd like to not have to use it, but as far as we can see that is not happening anytime soon.“
Frederik Maucksch, CTO at xymatic GmbH building the DELIGHTengine
„Workaround bugs and maybe use fast paths if we really really had to. I could also see it being useful to get stats about users.“
Patrick Cozzi, Cesium
„User issue diagnostics; details for vendor bug reports; workarounds.

Device performance detection (recommended/default effect level choices).

Issues with Higher DPI vs GPU power; resolution has increased but installed GPUs power hasn't always matched.

Feature detection doesn't always equate to a good user experience; just because a device can do things, switching everything on many result in a poor experience; interfere with networking etc.

Association settings suggestion; rather than lengthy setup benchmarking (e.g. 60% of people with this GPU use these settings)“
Ben Adams, Co-Founder & CTO Illyriad Games, Age of Ascent
„I think it's critical for bug reporting. It would be amazing to just get this information when something is not working. Especially that I mostly work with http://plask.org, and test in Safari. Chrome and FF only for big client projects.“
Marcin Ignac, variable.io