What Is My WebGL / GPU

What WebGL exposes about your GPU

WebGL is a thin JavaScript binding to your GPU via an OpenGL ES style pipeline. When a page creates a webgl or webgl2 context on a <canvas>, the browser asks the operating system for a graphics device and returns parameters such as MAX_TEXTURE_SIZE, MAX_RENDERBUFFER_SIZE, and MAX_VIEWPORT_DIMS. Those integers are real limits: exceed them and textures clamp or allocations fail.

The human-readable strings people care about, renderer and vendor, come from two layers. The baseline RENDERER and VENDOR parameters may already be masked on privacy-focused builds. The optional WEBGL_debug_renderer_info extension adds UNMASKED_RENDERER_WEBGL and UNMASKED_VENDOR_WEBGL, which read straight from the driver stack. That is how a site can print a string as specific as ANGLE (AMD, Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0) without installing a native binary.

Nothing here is uploaded to my server by the tool itself. The numbers are computed in your tab the same way any WebGL game reads them. Third-party analytics scripts on other sites are the usual reason people worry about this surface, not a diagnostic page you opened on purpose.

WebGL 1, WebGL 2, and the WebGPU successor

WebGL 1.0 tracks OpenGL ES 2.0: no transform feedback, limited texture formats, but universal support on anything still receiving security updates in 2026. WebGL 2.0 tracks OpenGL ES 3.0: multiple render targets, 3D textures, instancing, uniform buffer objects, and a stricter shading language. Most desktop GPUs and modern phones expose WebGL 2; very old Android WebViews may not.

WebGPU is the deliberate successor: a lower-level, explicit API modeled after Metal, Vulkan, and Direct3D 12, standardized by the W3C in the WebGPU specification. It is not a drop-in replacement for WebGL; engines like Three.js and Babylon.js maintain separate backends. In practice WebGL will remain in the field for years because content and teaching materials already depend on it, while new performance-critical work moves toward WebGPU compute shaders and finer memory control.

How this page detects your GPU

The client script creates an off-screen canvas, requests the highest WebGL version the browser offers, then queries parameters and extensions exactly as a game would on first launch. If WEBGL_debug_renderer_info is missing, the unmasked fields stay empty and you should assume the browser vendor is intentionally withholding driver marketing names. If WebGL cannot be created at all, the context call returned null: common causes include disabled hardware acceleration, blocked GPU access in enterprise policy, or a remote desktop session that never forwarded GL.

Extension count is the length of getSupportedExtensions(). Individual engines branch on names like OES_texture_float, EXT_color_buffer_float, or OES_vertex_array_object(promoted to core in WebGL 2). A long list usually correlates with a recent driver, not with "better gaming" by itself, but it does explain why one laptop can run a shader that another rejects at compile time.

Why you might read ANGLE or SwiftShader instead of a chip brand

ANGLE(Almost Native Graphics Layer Engine) is Google's compatibility layer that implements OpenGL ES on top of Direct3D, Metal, or Vulkan depending on platform. On Windows Chrome, seeing ANGLE in the renderer string usually means your real GPU is still underneath; ANGLE is the translator, not a software emulator. The ANGLE source tree documents the supported backends per operating system.

SwiftShader is different: it is a CPU rasterizer Chromium ships for fallback when the GPU process crashes, when hardware acceleration is toggled off, or when a driver is on a denylist. Performance tanks, but pages stay functional. If you expected an NVIDIA or AMD name and see SwiftShader, open your browser settings, confirm hardware acceleration is enabled, then update the OS GPU driver before chasing WebGL bugs in your own code.

Laptops with dual Intel and discrete NVIDIA silicon sometimes show Intel in WebGL while the discrete card handles full-screen games, because the browser process is pinned to the integrated GPU for power unless you force high-performance mode in the vendor control panel or operating-system graphics settings.

Privacy trade-offs around WebGL fingerprinting

Tracker scripts combine renderer string, extension list, precision quirks, and shader timing to build a stable identifier even when cookies are cleared. Defensive browsers reduce entropy: Firefox's Resist Fingerprinting mode and Brave's farbling deliberately lie or round values. Tor Browser goes further and warns users before exposing WebGL at all. Those mitigations are why your unmasked fields may read generic even though a AAA game still runs fine using the masked path.

Disabling WebGL entirely removes one fingerprint vector but breaks legitimate apps: Figma, Google Earth, most browser-based CAD viewers, and many data-viz dashboards. I treat WebGL as a power tool: leave it on for daily work, tighten the browser profile when you are doing sensitive research, and rely on first-party blocking lists to neuter known fingerprint vendors rather than starving your own productivity.

Turning hardware acceleration on or off (when it is the right move)

In Chromium, open chrome://settings/systemand ensure "Use graphics acceleration when available" is enabled, then restart. In Firefox, Preferences → Performance → uncheck "Use recommended performance settings" if you need to toggle hardware acceleration manually. Safari follows the macOS Graphics preference pane; on Apple Silicon the GPU is always present, but Remote Login or Screen Sharing can still alter which features are exposed to a session.

If you are chasing a single misbehaving site, try a fresh profile before globally disabling GL. Half of the "WebGL is broken" tickets I have filed turned out to be corrupted GPU caches or stale shader disk stores, which a profile reset clears faster than flipping global switches you will forget to undo.

Browser graphics APIs at a glance

Support matrices move quarterly; when in doubt, consult caniuse.com/webgl2 and caniuse.com/webgpu before locking architecture decisions.

Frequently asked questions

How can a website see my graphics card?

Any script on the page can create a WebGL context and read RENDERER, VENDOR, and, if permitted, the unmasked strings from WEBGL_debug_renderer_info. That is by design: developers need the data to tune shaders. Malicious use is the same mechanism with a different intent. Blocking third-party scripts or using a hardened browser profile limits who gets the signal.

What is ANGLE in my GPU info?

ANGLE is the translation layer between WebGL and the native graphics API of your OS. It is not a fake GPU; it is infrastructure Chromium uses so the same WebGL code runs on Direct3D, Metal, or Vulkan. Seeing ANGLE alongside an AMD or NVIDIA model is normal on Windows. Seeing SwiftShader is not normal for a healthy laptop and means CPU rendering.

Should I disable WebGL for privacy?

Only if your threat model demands it. Disabling WebGL removes a fingerprinting vector but also breaks many legitimate apps. Softer mitigations (uBlock Origin, Firefox Strict or Tor Browser, Brave shields) target trackers while preserving first-party experiences. I keep WebGL enabled and rely on script blocking for random blogs.

What is the difference between WebGL and WebGPU?

WebGL is a high-level retained-mode style API inherited from OpenGL ES. WebGPU is lower level: you manage buffers, pipelines, and command encoders explicitly, closer to Vulkan or Metal. WebGPU adds first-class compute shaders, which WebGL lacks unless you abuse vertex shaders creatively. New engines increasingly target WebGPU first and keep WebGL for fallback.

Why does my GPU show as Intel when I have an NVIDIA card?

Optimus-style laptops run the desktop compositor and many background apps on the integrated GPU to save power. The browser tab often starts there, so WebGL reads Intel. Forcing "High performance" in Windows graphics settings or the NVIDIA control panel moves Chromium to the discrete chip and the strings update after a restart.

Related tools

Screen geometry pairs with GPU work when you are debugging layout: open What Is My Screen Resolution. Browser identity and engine version sit beside renderer strings in What Is My Browser. Raw user-agent text (and Client Hints caveats) live on What Is My User Agent. If you are verifying that a VPN did not leave a secondary path exposed, run VPN Leak Test after you finish here.

Sources cited above

• Khronos WebGL 1.0 Specification
• Khronos WebGL 2.0 Specification
• WEBGL_debug_renderer_info extension registry
• W3C WebGPU Specification
• ANGLE project (Chromium source)

Common questions