WebGPU Test

Introduction

gpu that requests an adapter and summarizes features and limits the browser exposes, without claiming parity with native GPU-Z strings or driver control panels. Graphics developers, ML-in-browser experimenters, and IT verifying GPU stacks on Chromium builds use adapter probes before shipping WebGPU workloads. DeviceHub warns that adapter names and vendor strings may be privacy-reduced or generic under fingerprinting resistance, treat them as browser-visible hints, not factory EEPROM dumps. gpu is missing entirely on older engines. Browser-based CAD startups gate features on maxBufferSize limits read here before enabling mesh uploads on Intel integrated GPUs common in school labs. Compute shader demos still begin with adapter request, fail fast here before debugging WGSL compile errors elsewhere. WebGPU limits on maxStorageBufferBindingSize change between adapter generations, paste limit integers with GPU class (integrated/discrete) context. Feature level flags in chrome://gpu complement but do not replace adapter limits shown here. ML teams read adapter feature lists for bfloat16 before porting compute shaders, missing adapter fails fast here. gpu exists, check browser acceleration toggles. Tint/WGPU backend revisions shift limit integers, capture browser version with limit readouts. Shader authors porting WGSL compute kernels from native Vulkan should read maxComputeWorkgroupSizeX and maxStorageBufferBindingSize here before assuming laptop integrated GPUs accept the same buffer sizes as desktop discrete cards. ” Disabled hardware acceleration fails adapter request even when navigator.gpu exists, check browser acceleration toggles. External texture import from video elements needs separate feature flags, adapter success does not certify video texture paths.

What this tool does

gpu exists, the page requests an adapter, reads feature name lists and limit structures exposed to script, and reports unsupported cleanly on browsers without WebGPU shipping yet. It does not compile production shaders for benchmark scores, modify driver settings, or upload PCI IDs to DeviceHub analytics. Masked adapter labels are annotated as possible privacy behavior rather than errors. Dual-GPU laptops may hide which adapter was chosen when strings are privacy-masked. Feature level flags in chrome://gpu complement but do not replace adapter limits shown here. Feature name lists help ML teams see whether bfloat16 or timestamp queries exist before porting compute kernels. Privacy-reduced adapter names reading Generic are intentional, do not compare literally to native GPU utilities. WebGPU limits on maxBufferSize gate mesh uploads, read limits before blaming WGSL in apps. Compute-heavy demos should read timestamp-query support before assuming ordering guarantees. requestAdapterInfo may return vendor strings scrubbed to “unknown” on privacy-hardened channels, DeviceHub labels those outcomes as fingerprinting resistance rather than adapter enumeration failure. When requestAdapter resolves, optional adapter.requestAdapterInfo may return vendor strings scrubbed to “unknown” on privacy-hardened channels, DeviceHub labels those outcomes as fingerprinting resistance rather than adapter enumeration failure. WGSL language support in browser may lag native Vulkan feature set, adapter limits describe browser sandbox not full driver.

When to use it

Run before enabling WebGPU demos, after GPU driver updates, when teaching differences versus WebGL, or when black screens appear only on WebGPU paths. Prefer WebGL Test if WebGPU is absent but WebGL might suffice for your fallback. Run on virtual machines where GPU passthrough affects adapter visibility before blaming guest tools. Software adapters on VMs prove stack presence, not hardware performance claims. Feature level flags in chrome://gpu complement but do not replace adapter limits shown here. limits before uploading large storage buffers, missing adapter is cheaper to catch here than in WGSL compile logs. Software adapters on VMs support teaching demos, not hardware gaming performance claims. Safari WebGPU shipping timelines differ from Chromium, unsupported may be platform scope not user error. js WebGPU preview builds both gate on adapter limits; run this smoke before filing framework bugs when mesh uploads throw RangeError on school Chromebooks. Three.js r16x WebGPU renderer experiments and Babylon.js WebGPU preview builds both gate on adapter limits; run this smoke before filing framework bugs when mesh uploads throw RangeError on school Chromebooks. Indirect draw and multi-draw extensions when listed gate advanced rendering paths, missing features explain fallback shaders.

How it works

WebGPU adapter request returns promises resolving to adapter objects with optional info queries; browsers may mask vendor/device strings. Secure HTTPS hosts DeviceHub; WebGPU additionally expects capable Chromium versions or flagged builds on some channels. Hardware acceleration disabled at browser level can fail adapter request even when APIs exist. Typed permissions stay none, GPU enumeration here is not camera access. limits fields describe bounds, not current workload performance. Feature level flags in chrome://gpu complement but do not replace adapter limits shown here. Dual-GPU laptops may hide chosen GPU when strings masked, note integrated versus discrete class in tickets. Remote desktop often hides discrete GPUs, retest locally before driver RMA from browser smoke alone. Power-saving modes on hybrid laptops can hide discrete adapters until the machine is on AC power, retest plugged in when adapter request returns null despite chrome://gpu listing a capable GPU. Depth32float-stencil8 format support when absent breaks certain shadow map techniques, read format features before WGSL port.

Step-by-step instructions

1. Open WebGPU Test over HTTPS on a browser version that ships WebGPU when possible, with hardware acceleration enabled. Confirm hardware acceleration enabled before adapter request failures are filed as DeviceHub bugs.
2. Run adapter request smoke and note whether navigator.gpu is present or undefined. Paste chrome://gpu status summary internally when adapter limits look inconsistent with hardware.
3. Record feature limits understanding adapter names may be privacy-reduced generic strings. Retest after disabling dual-GPU switching software that hides discrete adapters from browsers.
4. Open WebGL Test if WebGPU is missing but older graphics APIs might cover your use case. Open WebGL Test same session when WebGPU missing to judge fallback viability.
5. Capture Browser Information for engine version beside GPU rows in support notes. Record laptop plugged versus battery state when adapters disappear on power saving modes.
6. When limits look smaller than expected, confirm whether remote desktop or software rendering is active before opening driver tickets. Treat privacy-reduced adapter names as hints only, not RMA evidence against GPU vendors.

Common problems

Expecting full marketing GPU names after privacy reduction leads to false bug reports. Unsupported on old WebViews is environmental. Disabled hardware acceleration yields failures unrelated to DeviceHub. Comparing adapter limits across machines with different GPUs without noting models confuses tickets. Assuming WebGPU availability equals WebGL availability, engines can block one independently. Feature level flags in chrome://gpu complement but do not replace adapter limits shown here. Chrome flags enabling WebGPU on unsupported hardware can yield flaky adapter requests, note flags in tickets. Chrome flags enabling WebGPU on weak hardware yield flaky requests, document flag state beside failures. Feature flags in chrome://gpu complement limits shown here, paste GPU status when limits look impossible. Confusing WebGPU “unsupported” with disabled hardware acceleration sends users to GPU driver forums when toggling “Use hardware acceleration when available” in browser settings fixes adapter request instantly. Adapter limits on maxBindGroups differ between integrated and discrete GPUs, school lab Intel cards need realistic expectations.

Privacy explanation

Adapter queries stay local for on-page display. DeviceHub does not upload GPU fingerprints during this smoke test. No mic or camera grants apply. Limit numbers describe capability ceilings, not personal files stored on disk. Feature level flags in chrome://gpu complement but do not replace adapter limits shown here. Shader compile errors happen after adapter request, missing adapter is cheaper to catch on this page first. WebGL fallback may work when WebGPU missing, open WebGL Test before declaring total graphics failure. Adapter feature lists describe GPU capability ceilings, not files on disk; still avoid posting full limit dumps publicly when internal fleet policies treat GPU class as sensitive inventory metadata. Shader module compilation limits on maxUniformBufferBindingSize gate uniform-heavy pipelines, read limits before blaming WGSL syntax.