WebGL Report
Read the GPU vendor, renderer, extensions, driver limits and shader precision your browser publishes — and whether they all describe one real machine. Free, no signup.
- Runs entirely in your browser
- Results are not uploaded
- No signup
See the graphics stack your browser publishes
The report reads the vendor and renderer strings, the extension list, the driver limits and the shader precision ranges, renders a probe triangle, then checks the WebGPU adapter against all of it.
Runs entirely in this browser. Nothing is uploaded, nothing is stored, no signup.
Now give every account its own device.
A clean browser is still one browser. Sendwin runs each profile in isolation with its own fingerprint, cookies and proxy, so the accounts you work on never look like they came from the same machine.
- Isolated profiles, each with its own fingerprint and cookies
- A proxy per profile, with the timezone bound to the proxy country
- Windows, macOS and Linux — plus cloud sessions when you need them
The free plan includes 10 minutes of cloud browsing a day.
What WebGL publishes about your machine
WebGL was designed to give pages enough information about the graphics stack to draw efficiently. In practice it publishes an unusually detailed portrait of your machine: a vendor string, a renderer string that usually names your exact GPU model and graphics backend, driver and shading-language versions, the list of supported extensions, several dozen numeric limits, and the precision ranges of the shader compiler. Where WebGPU exists, it describes the same adapter a second time in its own words.
This report reads all of it, plus a hash of a triangle your GPU actually shaded, and then checks whether the pieces fit together. That last part is what separates it from a spec sheet. The renderer string is the easy thing to rewrite; the limits, the extension list, the precision ranges and the rendered output are not, so most GPU spoofing comes apart at exactly the point where those have to agree with each other.
What the vendor and renderer strings give away
Behind the WEBGL_debug_renderer_info extension, Chromium publishes an unmasked vendor and renderer, typically something in the shape of “ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0)”. That single string names the GPU model, the driver generation and the graphics API in use, and it is readable without any permission, which makes it the most identifying value on the page. When it is hidden, the browser is making a deliberate privacy choice — but on a browser that identifies itself as Chromium, which ships the extension, its absence is a signal of its own.
The backend in the string implies an operating system
ANGLE is the translation layer Chromium uses to reach the platform's real graphics API, and it writes the target into the renderer string. Direct3D11 means Windows. Metal means macOS or iOS. OpenGL or Vulkan usually means Linux or Android. That makes the renderer a second, independent statement about your platform, sitting next to your user agent, your Client Hints and your installed fonts. A Direct3D11 backend on a browser claiming macOS is not an unusual configuration — it is a combination that cannot exist, and catching it needs no database at all.
Limits, extensions and precision have to match the GPU named
Every GPU model reports a fixed capability profile: a maximum texture size, uniform and attribute counts, anisotropy, a particular set of compression extensions and particular shader precision ranges. Those come from the driver rather than from the string. A high-end renderer name beside a 2048 maximum texture size, a Direct3D11 backend with S3TC compression missing, or an Apple silicon renderer exposing a desktop compression set are all contradictions. The shaded-triangle hash goes further still, because it measures arithmetic the GPU performed rather than anything it claims. When no GPU is reachable, a software rasterizer is named instead and every limit below it belongs to that rasterizer.
How the report is built
- 1
Open both contexts
The report acquires a WebGL and a WebGL2 context, reads the vendor, renderer, version and shading-language strings from each, then collects the extension list, the numeric limits and the shader precision ranges.
- 2
Render a probe shader
One triangle is drawn with a fragment shader built around sin, pow and fract, then read back pixel by pixel. The hash of that read describes the maths your GPU actually performed.
- 3
Check the pieces against each other
Vendor against renderer, backend against the operating system the browser claims, limits and extensions against the GPU named, WebGL1 against WebGL2, and the WebGPU adapter against all of it.
Other free checks
A GPU has to agree with the platform the browser claims and with everything rendered beside it. These check that neighbourhood.
WebGL fingerprint FAQ
What the renderer string gives away, why spoofing one value backfires, and what a software rasterizer actually means.
It is the combination of everything the graphics stack publishes: the vendor and renderer strings, driver and shading-language versions, the supported extension list, several dozen numeric limits, shader precision ranges, and the pixels a probe shader produces. Together they describe a particular GPU with a particular driver on a particular platform — stable across sessions, and requiring no cookie.
Not one value at a time. The renderer string is the easy part to rewrite, and it is surrounded by things that are not: the extension list, the texture and uniform limits, the precision ranges, the ANGLE backend and the rendered output of a real shader. Change the string alone and it now contradicts all of them, which is a stronger signal than the original string ever was. Either leave it alone, or use a browser that generates the whole graphics identity coherently.
SwiftShader, llvmpipe and the Microsoft Basic Render Driver are software rasterizers: the browser could not reach a GPU, so it is drawing on the CPU. That is completely normal on a VPS, in a virtual machine, over remote desktop, or with hardware acceleration switched off in the browser settings, and it is not evidence that anything is automating your browser. It does make a session distinctive, because most everyday visitors reach real hardware, so if your setup allows it, turning hardware acceleration back on makes the profile look more ordinary.
Some browsers do not expose WEBGL_debug_renderer_info, so the unmasked strings come back as generic values with no hardware named in them. That is the default privacy behaviour in parts of Safari and Firefox and it is unremarkable there. On a browser that identifies itself as Chromium, which ships the extension, the extension going missing is a mismatch between what the browser claims to be and how it behaves.
It should. WebGL and WebGPU read the same physical adapter, so the vendor and architecture WebGPU publishes have to describe the same hardware family the WebGL renderer names. A hardware WebGPU adapter beside a software WebGL renderer, or two different vendors across the two APIs, means one of the two answers was rewritten on the way out.
It removes this whole group of signals and hands over a rare one instead. Every mainstream browser ships WebGL, so a browser that cannot open a context at all is unusual enough to be worth noting by itself, and any site that needs 3D simply breaks. Reducing exposure works better when it does not require your browser to behave in a way no ordinary browser does.
Yes, slowly. A driver update can shift a version string or a precision range, a browser update can change the ANGLE backend, and switching hardware acceleration on or off changes the renderer entirely. What should not change is the internal agreement between them, which is what this report checks.
Still have questions? Talk to us →
How to read this report
This report describes the graphics stack this browser is talking to right now, and whether its own answers agree with one another. It is not a ranking: we hold no database of other visitors' GPUs, so we cannot say how common yours is. A software rasterizer is reported as an environment signal rather than as proof that anything is driving this browser — on a VPS, in a virtual machine or over remote desktop it is simply what the machine has.
One GPU story per profile, all the way down.
Sendwin generates the whole graphics identity together — renderer, limits, extensions and the pixels a shader produces — so nothing contradicts on a second look. Free for 30 days on Windows, macOS and Linux.
30-day free trial · $0 today · cancel anytime — your profiles stay on your machine