AI GPU Test

Introduction

AI GPU Test answers: “Can this browser use my GPU for AI-style workloads?” It layers several checks that matter for local AI demos, WebGPU apps, and on-device models — not a gaming benchmark.

The tool reports:

• AI readiness score (0–100) with a plain-language verdict
• WebGPU — adapter name and buffer limits
• WebGL2 — vendor/renderer and software-rendering detection
• WebNN — whether navigator.ml is exposed (when the browser supports it)
• Matrix benchmark — WebGPU matrix multiply with GFLOPS estimate, timing, and checksum validation
• Optional 10s WebGL sanity FPS (light Mandelbrot pass)

This is not MLPerf, CUDA, or VRAM diagnostics. It is a browser-local readiness signal before you trust a WebGPU LLM, image tool, or client-side ML page.

---

How the test works

1. Feature detection (parallel)

On Run AI GPU test, the tool concurrently:

1. WebGPU — navigator.gpu.requestAdapter() → requestDevice(), read adapter info and device.limits.
2. WebGL2 — create a WebGL2 context on the canvas, read vendor/renderer (and WEBGL_debug_renderer_info when allowed).
3. WebNN — if navigator.ml.createContext exists, attempt to create a context.

Software fallback flags renderers matching SwiftShader, llvmpipe, or “software” — meaning the browser may be on a CPU path, not your discrete or integrated GPU.

2. Readiness score

Points are awarded for:

Signal	Weight (approx.)
WebGPU adapter + device OK	35
WebGL2 available	15
WebGL2 not software-rendered	15
WebNN context OK	10
Matrix benchmark completed	10
Checksum matches CPU reference	5
Higher GFLOPS tier	5–10

Verdict bands:

Score	Verdict	Typical meaning
80–100	Strong	WebGPU + WebGL2; compute finished; no obvious software renderer
55–79	Limited	Partial stack or modest compute — small AI experiments may work
0–54	Weak	Missing WebGPU, blocked acceleration, or software rendering

3. Matrix multiply benchmark

When WebGPU is available, a compute shader multiplies two N×N float matrices (N = 128, 192, or 256).

• GFLOPS ≈ 2N³ / time (standard FLOP count for square matmul)
• Compute time — average of several GPU dispatches after warmup
• Checksum — sum of output compared to a CPU reference; Valid means the GPU result matches within tolerance

Matrix math is central to transformers and many vision models — a practical proxy for inference-style GPU compute in the browser.

4. Optional WebGL 10s check

Runs a lighter Mandelbrot pass (shared engine with GPU Stress Test) for ten seconds and reports average FPS. Useful when WebGPU passes but the page still feels sluggish — separates compute readiness from basic graphics smoothness.

---

Understanding each output

AI readiness score

What it is: Weighted summary of API availability, fallback risk, and whether matrix compute succeeded.

How to read it: Use the score for go / caution / fix settings — not for buying hardware. A 90 on a MacBook and 90 on a workstation are not equivalent absolute performance.

---

WebGPU compute card

Status	Meaning
OK	Adapter and device obtained — browser can run WebGPU compute
Fail	No navigator.gpu, null adapter, or device request blocked

Adapter line shows name/description when the browser exposes adapter.info.

---

WebGL graphics card

Status	Meaning
OK	Hardware-style renderer string
Warn	Software renderer (SwiftShader / llvmpipe)
Fail	WebGL2 context failed

Even with WebGPU, a bad WebGL path often means global hardware acceleration is off.

---

WebNN / NPU API card

Status	Meaning
OK	navigator.ml.createContext() succeeded
Warn	API missing or context blocked — common; many apps still use WebGPU

WebNN may route to GPU, NPU, or CPU depending on browser and OS — support is still evolving.

---

Software fallback card

Fail when WebGL reports a CPU renderer. Fix before trusting GFLOPS: enable hardware acceleration, update GPU drivers, disable forced software GL flags, exit remote-desktop-only sessions if possible.

---

GFLOPS estimate

What it is: Derived from timed WebGPU matmul only.

Measured: Relative browser WebGPU throughput for this matrix size.

Not measured: Tensor cores, FP16/BF16 ML ops, CUDA cores, or cloud AI performance.

GFLOPS (browser-relative)	Rough read
< 5	Very slow path — check software rendering or power saver
5–20	Modest — integrated GPU or overhead-heavy setup
20+	Stronger browser compute (still not native CUDA class)

---

Compute time / Matrix size / Checksum

• Matrix size — 128, 192, or 256 per side (preset buttons).
• Compute time — mean GPU dispatch time (ms); lower is faster at same N.
• Checksum Valid — GPU output matches CPU reference; Mismatch suggests driver bug or readback error — retry.

---

What this test measures

Measured	How
WebGPU availability	Adapter + device
WebGL2 acceleration path	Context + renderer string
WebNN exposure	navigator.ml probe
Software rendering risk	Renderer heuristics
Matrix compute throughput	WebGPU matmul GFLOPS
Result correctness	CPU vs GPU checksum

---

What this test does NOT measure

Not measured	Why
VRAM size / usage	No full VRAM API in browsers
GPU temperature	No sensor access
CUDA / ROCm / Metal native AI	Different runtimes
Model load / token/sec for LLMs	No model shipped in this tool
NPU TOPS ratings	WebNN may not expose detail
Cross-browser leaderboard	Engines and policies differ

---

Safety

• Matrix presets are small by design (max 256×256) — safer than unbounded stress.
• Heavy preset on old integrated GPUs may still warm the device — stop if uncomfortable.
• Close other GPU-heavy tabs for cleaner results.
• Enterprise policies may block WebGPU entirely — score reflects browser policy, not necessarily broken hardware.

---

Common use cases

1. Before trying a browser LLM or WebGPU demo

Goal: Confirm WebGPU works before spending time on a model download.

Run: Standard preset, score ≥ 80, WebGPU card OK, checksum Valid.

---

2. “WebGPU not working” support ticket

Goal: User pastes Copy results — support sees adapter error vs software renderer vs policy block.

---

3. After driver or browser update

Goal: Same preset before/after — compare GFLOPS and score.

---

4. Dual-GPU laptop — which GPU does the browser use?

Goal: Read WebGPU adapter + WebGL renderer; assign browser to “High performance” in Windows graphics settings and retest.

---

5. Distinguish AI readiness vs graphics stress

Need	Tool
WebGPU + matmul + WebNN	AI GPU Test (this page)
Sustained FPS / thermal graphics load	GPU Stress Test
CPU worker load	CPU Stress Test

---

Related tools

• GPU Stress Test — sustained WebGL2 Mandelbrot FPS stress after WebGPU readiness passes.
• CPU Stress Test — multi-core Worker load when the bottleneck may be CPU, not GPU.
• Memory Test — tab heap headroom before loading large browser AI models.
• Device Info — environment and browser context for the same session.