Back to Blog
Fingerprint

WebGL Fingerprinting: How Your GPU Identity Is Exposed

How WebGL renderer strings and rendering output reveal your GPU identity. Learn engine-level techniques to control WebGL fingerprint signals.

Introduction

WebGL (Web Graphics Library) enables hardware-accelerated 3D rendering inside the browser. Websites use it for games, data visualization, maps, and interactive content. But WebGL also exposes detailed information about your GPU: the vendor name, the renderer string, supported extensions, precision formats, and the pixel-level output of rendering operations. Tracking systems collect these values to build a GPU fingerprint that is highly stable and difficult to change. Because GPU configurations vary widely across devices, WebGL fingerprinting can distinguish users even when other signals are identical. This article explains how WebGL fingerprinting works, why common protections fall short, and how BotBrowser controls GPU identity at the rendering engine level.

Privacy Impact

WebGL fingerprinting is among the most powerful tracking signals available. Research from Inria and KU Leuven found that GPU renderer strings alone can narrow a user population to groups of fewer than 100. When combined with rendering output (drawing a specific scene and reading back pixel data), the uniqueness increases dramatically.

A 2020 study from the University of Illinois demonstrated that WebGL rendering produces device-specific output because GPUs implement floating-point arithmetic, texture sampling, and shader execution with slight hardware-level differences. Two GPUs from different manufacturers, even when running the same shader code, produce visually similar but numerically distinct framebuffers.

The scale of deployment is significant. According to the Princeton Web Transparency and Accountability Project, WebGL fingerprinting scripts were found on over 7% of the Alexa top 10,000 websites. The technique has become a standard component in commercial tracking libraries and is used alongside canvas, audio, and font fingerprinting to construct composite identifiers.

Technical Background

WebGL exposes GPU identity through several mechanisms.

Renderer and Vendor Strings

The most direct exposure comes from the WEBGL_debug_renderer_info extension:

gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
// "ANGLE (NVIDIA GeForce RTX 3080, D3D11)"

gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL)
// "Google Inc. (NVIDIA)"

These strings reveal the GPU manufacturer, model, and sometimes the graphics driver version. They are unique enough to significantly narrow the user population.

Rendering Output

WebGL rendering output varies at the pixel level due to hardware differences. A fingerprinting script might draw a complex scene with specific shaders, gradients, and transparency, then read back the framebuffer with readPixels(). The resulting pixel data is hashed to produce a stable identifier.

Sources of rendering variation include:

  • Floating-point precision. Different GPUs handle float operations with different rounding behavior, particularly in fragment shaders.
  • Texture filtering. Bilinear and trilinear filtering implementations vary between vendors.
  • Anti-aliasing. The default MSAA implementation differs across GPU architectures.
  • Driver-level optimizations. GPU drivers apply vendor-specific optimizations that affect pixel output.

Parameter Queries

WebGL exposes dozens of capability parameters through getParameter():

  • MAX_TEXTURE_SIZE, MAX_VIEWPORT_DIMS, MAX_RENDERBUFFER_SIZE
  • MAX_VERTEX_ATTRIBS, MAX_VARYING_VECTORS, MAX_FRAGMENT_UNIFORM_VECTORS
  • ALIASED_LINE_WIDTH_RANGE, ALIASED_POINT_SIZE_RANGE
  • Supported compressed texture formats, shader precision formats, and extensions

Each of these values reflects the GPU's capabilities and contributes to the overall fingerprint.

WebGL2 Extensions

WebGL2 adds additional surface area. Parameters like MAX_3D_TEXTURE_SIZE, MAX_ARRAY_TEXTURE_LAYERS, and MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS further differentiate hardware. The getShaderPrecisionFormat() method returns precision details per shader type, which vary between GPU families.

Common Protection Approaches and Their Limitations

Blocking WebGL entirely prevents fingerprinting but breaks a large portion of the modern web. Maps, 3D product viewers, data dashboards, and games all depend on WebGL. Disabling it makes your browser less capable and also creates a distinctive fingerprint signal: the absence of WebGL is itself uncommon and trackable.

Spoofing renderer strings via a browser extension can change what UNMASKED_RENDERER_WEBGL returns, but this only addresses one part of the fingerprint. The actual rendering output still comes from your real GPU. A site can draw a test scene, read back pixels, and determine your actual GPU class from the rendering characteristics. The mismatch between the reported string and the rendering behavior is itself a strong signal.

Adding noise to readPixels output via JavaScript interception modifies the returned framebuffer data. But noise injection is detectable: rendering the same scene twice should produce identical output. If it does not, noise injection is present. Some extensions try to cache and replay noise, but this approach breaks down with dynamic scenes and varied draw calls.

Using software rendering (like SwiftShader or Mesa llvmpipe) produces consistent output across hardware but creates its own distinct fingerprint. Software renderers have characteristic precision behavior and parameter values that identify them specifically.

The core challenge is that WebGL fingerprinting combines reported parameters with actual rendering output. Effective protection must control both simultaneously.

BotBrowser's Engine-Level Approach

BotBrowser controls WebGL identity at the Chromium rendering engine level, ensuring that reported parameters and actual rendering output are both consistent with the loaded profile.

GPU Identity Control

When a fingerprint profile is loaded, BotBrowser configures the WebGL subsystem to report the profiled GPU's identity:

  • Renderer and vendor strings match the target device. A profile for a system with an Intel UHD 630 reports that GPU's exact renderer and vendor strings.
  • Parameter values (max texture size, viewport dimensions, precision formats, etc.) all match the profiled GPU's capabilities. These are not random values. They correspond to real hardware configurations.
  • Extension lists report exactly the extensions supported by the profiled GPU. No extensions are added or removed compared to the real device.

Rendering Output Consistency

BotBrowser's profile system includes information about the target GPU's rendering characteristics. When combined with the --bot-noise-seed flag, rendering output becomes deterministic and consistent with the profiled device. The engine applies controlled variation that produces authentic-looking pixel data without exposing your actual GPU.

This covers:

  • Fragment shader output precision
  • Texture sampling behavior
  • readPixels() data for any drawn scene
  • getShaderPrecisionFormat() results
  • Framebuffer blending operations

WebGL2 Coverage

The same controls apply to WebGL2. Parameters, extensions, and rendering behavior are all derived from the profile. There is no gap between WebGL1 and WebGL2 protection.

Cross-API Consistency

BotBrowser ensures that WebGL data aligns with other profile signals. The GPU reported by WebGL matches what appears in navigator.userAgentData, what canvas rendering produces, and what WebGPU reports (if enabled). This cross-API consistency is critical because tracking systems commonly cross-check GPU-related signals across multiple APIs.

Configuration and Usage

Basic WebGL Protection

Load a profile to configure all WebGL parameters:

chrome --bot-profile="/path/to/profile.enc" \
       --user-data-dir="$(mktemp -d)"

WebGL Configuration Override

Control WebGL behavior independently:

# Use profile's WebGL settings (default)
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-webgl=profile

# Use real system GPU (no WebGL protection)
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-webgl=real

# Disable WebGL entirely
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-webgl=disabled

Deterministic Rendering with Noise Seed

For reproducible WebGL fingerprints:

chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=42 \
       --user-data-dir="$(mktemp -d)"

Playwright Integration

const { chromium } = require('playwright');

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-config-webgl=profile',
    '--bot-noise-seed=42'
  ]
});

const page = await browser.newPage();
await page.goto('https://example.com');

Puppeteer Integration

const puppeteer = require('puppeteer');

const browser = await puppeteer.launch({
  executablePath: '/path/to/botbrowser/chrome',
  defaultViewport: null,
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-config-webgl=profile',
    '--bot-noise-seed=42'
  ]
});

const page = await browser.newPage();
await page.goto('https://example.com');

Controlling WebGL Image Noise Separately

# Disable WebGL image noise while keeping other WebGL protection
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-noise-webgl-image=false

Verification

To verify that WebGL protection is working:

Renderer string check. Open the browser console and query UNMASKED_RENDERER_WEBGL. The value should match the profile's target GPU, not your actual hardware.

Parameter consistency. Check several WebGL parameters (MAX_TEXTURE_SIZE, precision formats, extension list) and confirm they match the expected values for the profiled GPU.

Cross-session stability. Run the same WebGL fingerprinting routine in two sessions with the same profile and noise seed. The results should be identical.

Cross-machine stability. Run the test on different hardware with the same profile and seed. The WebGL fingerprint should match.

Visit BrowserLeaks, CreepJS, or similar fingerprint testing sites to compare your WebGL output against your profile's expected values.

Best Practices

  • Use --bot-config-webgl=profile (default). This ensures all WebGL parameters come from the profile. Only switch to real if you specifically need native GPU access.
  • Combine with --bot-noise-seed for deterministic output. Without a seed, WebGL rendering noise varies between sessions. A fixed seed ensures reproducibility.
  • Match WebGL and WebGPU settings. If your profile has both WebGL and WebGPU data, keep both at profile to maintain consistency. A mismatch between the GPU reported by WebGL and WebGPU is a detectable inconsistency.
  • Do not manually override renderer strings. BotBrowser handles this through the profile. Manually setting renderer strings without matching the rendering behavior creates inconsistencies.
  • Test with fingerprint checker sites. Verify that your WebGL fingerprint matches expectations before deploying to production.

FAQ

Q: Does WebGL fingerprinting work without the WEBGL_debug_renderer_info extension? A: Partially. Without the extension, renderer and vendor strings are unavailable, but rendering output, parameter values, and precision formats still vary by GPU. The rendering-based fingerprint alone is often sufficient to narrow the user population.

Q: Can I use BotBrowser with WebGL-intensive applications like 3D games? A: Yes. BotBrowser's WebGL control operates at the identity and fingerprint level. Rendering performance comes from your actual GPU. Games and 3D applications work normally.

Q: Does the WebGL protection affect canvas fingerprinting? A: Canvas 2D and WebGL use different rendering paths, but BotBrowser controls both through the profile. They produce consistent results that align with the same profiled device.

Q: What happens if a site requests WebGL extensions not in my profile? A: BotBrowser reports only the extensions listed in the profile. Requests for unsupported extensions return null, consistent with the behavior of the profiled GPU.

Q: Is WebGL2 protected separately from WebGL1? A: Both are controlled by the same profile and configuration. The --bot-config-webgl flag applies to both WebGL1 and WebGL2 contexts.

Q: How does BotBrowser handle WebGL in Web Workers? A: OffscreenCanvas WebGL contexts in workers are subject to the same engine-level controls as main-thread contexts. The fingerprint is consistent across both.

Summary

WebGL fingerprinting combines GPU identity strings, capability parameters, and pixel-level rendering output to create a powerful tracking signal. Because it reaches into the hardware layer, JavaScript-based protections cannot fully address it. BotBrowser controls WebGL identity and rendering at the Chromium engine level, ensuring that every API surface returns values consistent with the loaded fingerprint profile. Combined with --bot-noise-seed for deterministic output and --bot-config-webgl for explicit control, BotBrowser provides complete WebGL fingerprint protection.

For related topics, see What is Browser Fingerprinting, WebGPU Fingerprint Protection, Canvas Fingerprinting, and Audio Fingerprint Protection.

#webgl#fingerprinting#gpu#privacy#webgl2