Cinevva

English

简体中文

English

简体中文

Appearance

WebGL & WebGPU Checker ​

Find out what your browser can do with graphics. This tool checks whether your browser supports WebGPU, WebGL 2, and WebGL 1, then shows your GPU, key limits, and device details. It all runs locally in your browser, nothing is uploaded.

Why This Matters for Web Games ​

If you're building or playing browser games, the rendering API decides what's possible. WebGL 2 is the dependable baseline that works almost everywhere. WebGPU is the newer API that unlocks compute shaders and modern GPU features, but support varies by browser and device. Checking what a device actually reports is the fastest way to debug "it works on my machine" problems and to decide whether to ship a WebGPU path with a WebGL 2 fallback.

The GPU vendor and renderer line is especially useful. It tells you whether a browser is running on the real GPU or falling back to slow software rendering, which is a common cause of mysterious frame-rate drops.

What It Checks ​

  • WebGPU: whether navigator.gpu exists, the adapter vendor and architecture, and limits like max texture size, max buffer size, and compute workgroup sizes, plus the supported feature list.
  • WebGL 2 and WebGL 1: support, GPU vendor and renderer, GLSL version, and limits like max texture size, render buffer size, and vertex attributes.
  • Device: pixel ratio, logical CPU cores, device memory, screen size, and touch points.

WebGPU vs WebGL: What's the Difference ​

WebGL and WebGPU are both ways to talk to the GPU from a web page, but they come from different eras.

WebGL is based on OpenGL ES, a graphics API from the 2000s. WebGL 1 shipped in 2011, WebGL 2 in 2017. It's a pure graphics pipeline: you give it vertices and shaders, it draws pixels. It's everywhere, it's stable, and it's what almost every browser game has run on for a decade.

WebGPU is the modern replacement, designed around how today's GPUs actually work (it maps to Vulkan, Metal, and Direct3D 12 underneath). It shipped in Chrome in 2023 and reached every major browser by late 2025. The two big additions are compute shaders (running general work on the GPU, not just drawing, which matters for physics, particles, culling, and AI) and much lower CPU overhead, so you can push far more objects per frame.

WebGL 2WebGPU
Released20172023, broad support by late 2025
Based onOpenGL ES 3.0Vulkan / Metal / D3D12
Compute shadersNoYes
CPU overheadHigherMuch lower
Shader languageGLSLWGSL
Browser supportUniversalModern browsers only
Best roleDependable baselinePerformance and compute upgrade

The practical takeaway for 2026: WebGPU is faster and more capable, but WebGL 2 still has wider reach. Most teams ship WebGL 2 as the baseline and add a WebGPU path where it's available. Engines like Three.js, Babylon.js, and PlayCanvas already do this automatically with a WebGL 2 fallback, which is why the checker above tests for both.

WebGPU Capabilities Explained ​

WebGPU has a set of optional features beyond its core. The checker groups them the way they matter to a game, and here's what each group does. Every feature name below links to its definition in the W3C WebGPU spec.

Texture compression: BC, ETC2, and ASTC ​

GPU-compressed textures stay compressed in video memory, so they cut both VRAM use and download size far more than PNG or JPEG. The catch is that the formats are hardware-specific. Desktop GPUs speak BC (also called S3TC or DXT), most Android devices speak ETC2, and modern mobile speaks ASTC. Shipping to every device usually means providing more than one format, often through a KTX2 container with Basis Universal that transcodes to whatever the device supports. The "sliced 3D" variants extend BC and ASTC to volumetric 3D textures. This is why the checker lists each format separately, it tells you exactly which compressed textures you can ship to this device.

Shaders and compute ​

This is where WebGPU pulls ahead of WebGL. Compute shaders let you run general work on the GPU, not just drawing, which is what powers GPU particles, physics, culling, and on-device AI. shader-f16 adds 16-bit floats for roughly double the math throughput where full precision isn't needed. subgroups let threads in a GPU wave share data directly without round-tripping through memory, a big win for reductions and prefix sums. float32-filterable allows smooth filtering of high-precision textures, used in HDR and data-heavy effects.

Rendering and blending ​

These features unlock higher-quality output. float32-blendable and rg11b10ufloat-renderable enable HDR and high-dynamic-range render targets. dual-source-blending supports advanced blend effects like proper subpixel text and certain transparency techniques. bgra8unorm-storage lets shaders write directly to common swap-chain formats.

Depth and clipping ​

depth-clip-control and depth32float-stencil8 give precise control over the depth buffer, which matters for shadows, large open worlds, and avoiding z-fighting. clip-distances lets shaders clip geometry against custom planes, useful for portals, water reflections, and mirrors.

Profiling and core ​

timestamp-query reads GPU-side timing so you can profile exactly how long passes take, the key to fixing frame-rate problems. indirect-first-instance supports GPU-driven rendering where the GPU decides what to draw. core-features-and-limits is the baseline every conformant WebGPU device must support.

What the GPU Limits Mean ​

The details panel reports the limits your GPU exposes. The ones that matter most for games:

  • GPU renderer / vendor — the actual graphics chip your browser is using. If it says SwiftShader or llvmpipe, you're on software rendering and games will be slow.
  • Max texture size — the largest texture dimension the GPU accepts (commonly 8192 or 16384 px). It caps the resolution of your textures and render targets.
  • Max compute workgroup size (WebGPU) — how many threads a compute shader can run per group, which matters if you offload physics or particles to the GPU.
  • Max buffer size (WebGPU) — the largest single GPU buffer, a ceiling on how much geometry or data you can upload at once.
  • Device pixel ratio — how many physical pixels back each CSS pixel. High-DPI screens (2x, 3x) render far more pixels, which is a common hidden cause of low frame rates on phones.

Common Questions ​

Does my browser support WebGPU? ​

Run the checker above. If WebGPU shows "Supported," your browser exposes the WebGPU API and found a compatible GPU adapter. As of 2026, WebGPU ships by default in Chrome and Edge (113+), Firefox, and Safari 26 on macOS, iOS, and iPadOS, but older browsers and some devices still only have WebGL 2. The tool reads your actual capabilities, so it's the most reliable answer for your exact setup.

What is the difference between WebGL and WebGPU? ​

WebGL is the long-standing browser graphics API based on OpenGL ES, and WebGL 2 is its widely supported version. WebGPU is the newer API designed around how modern GPUs actually work, adding compute shaders and lower overhead. WebGPU is faster and more capable, but WebGL 2 has broader support, so most web games ship WebGL 2 as a baseline and use WebGPU where it's available.

Why does my GPU show as software or "SwiftShader"? ​

If the renderer line shows something like SwiftShader, llvmpipe, or "Software," your browser is rendering on the CPU instead of the GPU. That usually means hardware acceleration is disabled, a driver is blocklisted, or you're in a restricted environment. Enabling hardware acceleration in your browser settings or updating your GPU driver normally fixes it, and it's a frequent cause of poor web-game performance.

Is this WebGL checker safe? Does it upload anything? ​

It's safe and fully local. The tool only reads capability information your browser already exposes to any web page, and it runs entirely in your browser. Nothing is uploaded or stored.