GPU Stress Test

Introduction

GPU Stress Test pushes your graphics pipeline through WebGL2: every frame draws a full-screen triangle and runs a Mandelbrot set fragment shader with a configurable iteration count. More iterations and higher canvas resolution mean more GPU work per frame.

The tool reports:

• FPS (instant) — frame-to-frame rate
• FPS (1s avg) — rolling one-second average (smoother trend)
• Min FPS — lowest 1s average seen after the run warms up
• GPU vendor / renderer when the browser exposes them
• A warning when software rendering is detected (SwiftShader, llvmpipe)

Use it to verify hardware acceleration, compare driver updates, or watch FPS hold vs drop under sustained load. It is not 3DMark, FurMark, or a game benchmark — it is a browser-local WebGL stress signal.

How the test works

1. WebGL2 context

The canvas requests webgl2 with powerPreference: 'high-performance' and no antialiasing. A single fullscreen triangle (three vertices) covers the framebuffer — standard trick to avoid quad edge cases.

2. Mandelbrot fragment shader

Per pixel:

1. Map gl_FragCoord to complex plane coordinates (animated offset via u_t).
2. Iterate up to u_iter times (slider 100–5000, shader loop cap 5000).
3. Color by escape iteration with a time-based palette.

Higher Iterations increases ALU work per pixel. Higher Resolution increases pixel count (fill rate).

3. Frame loop

requestAnimationFrame drives the loop. Each frame:

• Updates uniforms (u_t, u_res, u_iter)
• Calls drawArrays(TRIANGLES, 0, 3)
• Computes instant FPS from frame delta
• Maintains a 1-second sliding window for average FPS
• Updates Min FPS when the window has >30 samples and a new lower 1s average appears

4. GPU identification

If available, WEBGL_debug_renderer_info provides unmasked vendor/renderer; otherwise the tool falls back to VENDOR / RENDERER (often generic or redacted).

Understanding each output

FPS (instant)

What it is: 1000 / frame_delta_ms for the last frame.

How to read it: Spiky; good for seeing hitches. Vsync may cap near monitor refresh (60, 120, 144 Hz) even when the GPU could do more work.

FPS (1s avg)

What it is: Mean of instant FPS samples in the last 1000 ms.

How to read it: Best single number for sustained performance. Compare this across runs at the same settings.

Min FPS

What it is: Lowest 1s average recorded after enough samples (>30 in window).

How to read it: “Worst sustained second” during the session — useful for stutter and throttle detection. Not the same as 1% low in games.

Frames / Elapsed

What it is: Total frames drawn and seconds since Start stress.

How to read it: Sanity check that the loop ran continuously. Elapsed stops increasing when you Stop.

Iterations & Resolution

Iterations: Shader loop bound — primary load knob for ALU.

Resolution: Multiplier on canvas width (container width × scale) and fixed base height (420px × scale). Shown as W×H in copy text.

Vendor / Renderer

What it is: WebGL strings identifying the GL implementation.

What this test measures

What this test does NOT measure

Safety

• High settings on integrated graphics heat the whole package (CPU + GPU share a cooler).
• Stop if the tab freezes, artifacts spread, or the system shuts down.
• Prefer AC power and a ventilated surface for long runs.
• Reduce Resolution first if stuttering; then Iterations.

Common use cases

1. Confirm hardware acceleration is on

Goal: Make sure the browser uses your real GPU, not a software fallback.

How to run: Open the page; read Renderer before starting. Click Start stress for 20s.

Healthy: Renderer mentions Intel, AMD, NVIDIA, Apple, Qualcomm, etc. FPS is reasonable for your class of GPU.

Red flag: SwiftShader, llvmpipe, or software in the renderer string — enable hardware acceleration in browser settings and update drivers.

2. New PC or GPU — quick sanity check

Goal: Discrete or integrated GPU responds under load without immediate tab crash.

How to run: Default 1500 iterations, 1.0× resolution, 30–60s run.

Healthy: Stable Mandelbrot animation; FPS not stuck at 0; no instant tab kill.

Red flag: Black canvas, shader compile error, or single-digit FPS on a desktop GPU at low settings — driver or WebGL2 issue.

3. Driver update before / after

Goal: Same machine, same browser, same slider values — did average FPS change?

How to run: Copy results after 60s at fixed iterations/resolution; update driver; reboot; repeat.

Compare: FPS (1s avg) at elapsed 45–60s and Min FPS — not instant spikes only.

4. Laptop thermal / power throttling

Goal: See if the GPU cannot sustain frame rate when hot.

How to run: AC power, 1500–2500 iterations, 1.0–1.5× resolution, run 2–3 minutes.

Pattern: High 1s avg in the first 30–60s, then 20–40% lower sustained avg — common on thin laptops with integrated graphics.

5. Integrated vs discrete (dual-GPU laptops)

Goal: Understand which GPU the browser selected (often the integrated chip for power saving).

How to run: Check renderer string; on Windows, compare before/after assigning the browser to “High performance” in Graphics settings.

Note: The tool cannot force GPU switch — it only reports what WebGL sees.

6. Remote support — “Is WebGL working?”

Goal: User pastes Copy results with vendor, renderer, FPS, and canvas size.

How to run: 30s at moderate settings; support checks for software renderer and absurdly low FPS.

7. Browser comparison (same PC)

Goal: See if one browser throttles WebGL more (extensions, flags).

How to run: Chrome vs Firefox vs Edge, identical iteration/resolution, 60s each.

Interpretation: 10–20% FPS variance is normal; huge gap → profile, flags, or hardware acceleration setting.

Quick reference

Related tools

• CPU Stress Test — load logical CPU cores separately from GPU fragment work.
• AI GPU Test — WebGPU compute readiness vs this WebGL2 FPS stress test.
• Memory Test — tab JavaScript heap headroom before heavy web apps.
• Device Info — screen, browser, and environment context.