# WebGL Report

> Does this browser run WebGL? A draw test, your GPU, every limit and extension, and a plain verdict you can copy into a bug report.

- Page: https://codethatmoves.com/tools/webgl/webgl-report/
- Site: Code That Moves
- Category: WebGL and 3D
- Free, runs in the browser, nothing is uploaded
- Last checked: 2026-11-03

## What it does

- Detects WebGL 1, WebGL 2 and WebGPU, with the WebGPU adapter, its features, every limit and the software-fallback flag
- Draws a triangle and reads the pixel back, so WebGL that exists but cannot render is caught
- Flags software renderers such as SwiftShader and llvmpipe, and names the ANGLE backend (Direct3D, Vulkan, Metal, OpenGL)
- Shader precision (highp in fragment shaders), compressed texture formats and what KTX2 transcodes to
- Float render targets tested by rendering, texture size, limits and extensions for WebGL 2 and WebGL 1, each linked to the Khronos registry
- Copy the report as text or JSON, or download the JSON

## How to use it

1. Open the page. The tests start by themselves and finish in under a second.
2. Read the verdict and the checks. Each one says what it means for 3D, shader and particle work.
3. Copy the report as text or JSON, or download the JSON, and attach it to a bug report or a support ticket.

## What it checks and why

Most WebGL checks stop at asking the browser for a context. That answer can be wrong: some browsers and embedded web views hand back a context that cannot draw anything. This page also compiles a shader, draws a triangle into an off-screen buffer and reads the pixel back, so a pass here means the pipeline works end to end.

It also tells apart a real GPU from a software renderer. SwiftShader, llvmpipe and the Microsoft Basic Render Driver run WebGL on the CPU. Simple scenes work on them; the fluid, particle and ray-marched examples in the Lab do not run at a usable speed.

Float render targets decide whether fluid simulations, GPGPU particles and HDR bloom can run at all. The report tests them by rendering into a float texture instead of trusting the extension name.

For shader and asset work it also reads the shader precision of each stage (some mobile GPUs have no highp in fragment shaders), the compressed texture formats the GPU accepts and what a KTX2 texture would be transcoded to, using the same order as three.js KTX2Loader.

## Reference data

| Limit | What it means |
| --- | --- |
| `MAX_TEXTURE_SIZE` | Largest texture side in pixels. 4096 is the practical minimum, 16384 is common on desktop. |
| `MAX_CUBE_MAP_TEXTURE_SIZE` | Largest cube-map face. Matters for reflections and sky boxes. |
| `MAX_RENDERBUFFER_SIZE` | Largest off-screen buffer. Caps the size of high-resolution exports. |
| `MAX_VIEWPORT_DIMS` | Largest drawing area. Large 4K or 8K canvases need a high value. |
| `MAX_VERTEX_ATTRIBS` | Per-vertex inputs a shader can read. Instanced and skinned meshes use many. |
| `MAX_VERTEX_UNIFORM_VECTORS` | Constants available to the vertex shader. Bone matrices for skinned models use these. |
| `MAX_FRAGMENT_UNIFORM_VECTORS` | Constants available to the pixel shader. Many lights need many. |
| `MAX_VARYING_VECTORS` | Values passed from the vertex to the pixel shader. |
| `MAX_TEXTURE_IMAGE_UNITS` | Textures one pixel shader can sample at once. |
| `MAX_VERTEX_TEXTURE_IMAGE_UNITS` | Textures a vertex shader can sample. Needed for displacement and GPGPU. |
| `MAX_COMBINED_TEXTURE_IMAGE_UNITS` | Textures across all shader stages. |
| `MAX_3D_TEXTURE_SIZE` | Largest volume texture side (WebGL 2): volume rendering, colour look-up tables. |
| `MAX_ARRAY_TEXTURE_LAYERS` | Layers in a texture array (WebGL 2): sprite atlases and terrain. |
| `MAX_DRAW_BUFFERS` | Render targets written in one pass. 2 or more is needed for GPGPU particles and deferred shading. |
| `MAX_COLOR_ATTACHMENTS` | Colour buffers on one framebuffer. |
| `MAX_SAMPLES` | Highest multisample anti-aliasing level. |
| `MAX_UNIFORM_BUFFER_BINDINGS` | Uniform buffers bound at once (WebGL 2). |

## Specs and sources

- [MDN: WebGL API](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API)
- [Khronos: WebGL 2.0 specification](https://registry.khronos.org/webgl/specs/latest/2.0/)
- [MDN: WEBGL_debug_renderer_info](https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_debug_renderer_info)
- [MDN: WebGPU API](https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API)
- [WebGL support statistics (web3dsurvey)](https://web3dsurvey.com/)
- [Khronos: WebGL extension registry](https://registry.khronos.org/webgl/extensions/)

## Limits

- Browsers can hide the real GPU name. Chrome, Firefox and Safari may report a generic renderer to limit fingerprinting.
- One run is a snapshot. A laptop with two GPUs can use a different one in another window or on battery.
- Passing here does not guarantee a given scene runs at 60 fps. It shows the features are there, not the speed.

## Questions

### How do I turn WebGL on?

In Chrome and Edge, open Settings, search for hardware acceleration and switch on Use graphics acceleration when available, then restart the browser. In Firefox, open Settings, General, Performance, clear the recommended setting and tick Use hardware acceleration when available. If the report still fails, update the GPU driver.

### How do I see why Chrome blocks WebGL or WebGPU?

Open chrome://gpu (edge://gpu in Edge). The Graphics Feature Status list shows whether WebGL, WebGL 2 and WebGPU are hardware accelerated, software only or disabled, and the problems section names the driver or blocklist entry behind it. In Firefox, about:support has the same under Graphics.

### What does major performance caveat mean?

A page can ask for a WebGL context with failIfMajorPerformanceCaveat. The browser then refuses when it would only render on the CPU. This report asks for one that way, so a refusal shows up here as a software renderer.

### What is the difference between WebGL 1 and WebGL 2?

WebGL 2 follows OpenGL ES 3.0. It adds 3D textures, uniform buffers, instancing as a core feature, multiple render targets and float render targets that need no vendor tweaks. Current versions of Three.js and PixiJS prefer it.

### How do I get a WebGL 2 report?

Open this page in the browser you want to test. The report checks WebGL 1 and WebGL 2 separately, draws a real frame with each, and lists the WebGL 2 limits, such as maximum texture size, 3D texture size and draw buffers, next to the WebGL 1 values. Copy the report to paste it into a bug ticket.

### Why does the report say software renderer?

The browser is drawing on the CPU, usually because hardware acceleration is off, the driver is blocked or the machine is a remote desktop or a virtual machine. WebGL still works, only slowly.

### Is WebGPU the same as WebGL?

No. WebGPU is a newer API with compute shaders and lower overhead. Nothing in the Lab depends on it; WebGL 2 covers every example.

### Which browsers support WebGPU?

Chrome and Edge since version 113 on Windows, macOS and ChromeOS, on Linux since 144 (Intel Gen12+ GPUs), and Chrome on Android since 121. Safari since 26, on Mac, iPhone and iPad. Firefox since 141 on Windows and since 145 on macOS Tahoe with Apple silicon; Firefox on Linux, Intel Macs and Android does not have it yet. A browser can still return no adapter when the GPU or driver is blocked, which the report above shows.
