Shader Performance Test

What is this tool?

The Shader Performance Test measures how fast your GPU runs a heavy fragment shader. It ray-marches a scene through a WebGL2 GLSL ES 3.00 fragment shader whose complexity you choose — a sphere, a gyroid, a fractal torus with fBm noise, or a quaternion fold — and times the frames it produces.

The shading work scales with an iteration count clamped in-shader between 16 and 512, and at the higher complexity tiers a second reflection-ray loop is added, so the per-pixel cost climbs steeply as you turn it up. Render scale super-samples the canvas to add fill work on top.

All metrics come from real frame deltas via performance.now(). A short warm-up window is excluded so shader-compilation cost does not skew the result, and no GPU temperature, power, clock or utilisation figure is produced.

How to use it

1. Pick a complexity and iterationsComplexity runs low (sphere), medium (gyroid), high (fractal torus, the default) and extreme (quaternion fold). Iterations default to 128 and are clamped to 16-512 in the shader. Higher means heavier.
2. Set effects and render scaleThe procedural effects setting, combined with medium-or-higher complexity, enables a secondary reflection ray loop. Render Scale is a super-sampling multiplier that raises fill cost.
3. Run for a set durationChoose a duration (30 seconds by default). A 400 ms warm-up at the start is rendered but excluded from the recorded telemetry, so the numbers reflect steady state.
4. Run the complexity comparisonThe comparison sweep runs low, medium, high and extreme in turn (a few seconds each) so you can see on your own hardware how each tier costs performance.

What the results mean

Average and 1% low FPS

Average FPS is 1000 divided by the mean frame time over the measured window. The 1% low is the mean of the slowest 1% of frames as an FPS, which surfaces the stutter the average smooths over.

Frame time (avg / min / max)

The wall-clock interval between frames from performance.now(), reported as average, minimum and maximum. This is whole-frame time, not isolated GPU time.

Stability and jitter

Jitter is the standard deviation of frame times; stability is 100 × (1 − min(1, stdDev / avgFrameTime)) as a percentage. A frame over 33.33 ms is counted as a drop.

Frames and drops

Total measured frames and the number that exceeded the 33.33 ms budget, so you can see both throughput and pacing at a glance.

What it can detect

• Fragment-shader throughput on your GPU as complexity and iterations rise
• How each complexity tier — sphere to quaternion fold — costs performance, via the comparison sweep
• The extra cost of the secondary reflection-ray loop at higher tiers
• Stutter and pacing through the 1% low and stability figures, not just the average FPS

Limits worth knowing

A browser can only report what the platform gives it. These are the honest boundaries of this page, so a result is never read as more than it is.

• It cannot read GPU temperature, power, clocks, utilisation or VRAM. GPU identity comes only from the WEBGL_debug_renderer_info extension, which some browsers mask.
• It reports a set of FPS / frame-time / stability metrics, not a single composite score — there is no fabricated points value.
• The 400 ms warm-up is excluded from telemetry, but there is no tab-blur pause, so switching away mid-run can distort the frame times.
• Manual stop produces a valid partial result from the frames collected so far; treat it as a shorter sample, not a full run.
• Frame rate is capped by the display refresh rate via requestAnimationFrame, and requires WebGL2 support.

Tips

• Use the complexity comparison to place your GPU: the shape of the fall-off from low to extreme is more telling than any single number.
• Raise iterations to stress arithmetic throughput and render scale to stress fill rate — changing them separately tells you which one your card runs out of first.
• Keep the tab focused; the warm-up is handled for you, but there is no visibility pause to protect the numbers if you alt-tab.

Troubleshooting

Related documentation

• DisplayVolume Shader TestAn interactive volumetric ray-marching shader you can tune live to see how your GPU handles heavy fragment work.
• DisplayVolume Shader BenchmarkA repeatable volumetric-shader benchmark with a warm-up, a transparent score and a controlled comparison mode.
• DisplayRendering to Texture TestStress your GPU's framebuffer and post-processing path with real multi-pass render-to-texture pipelines.
• DisplayStress My GPUPush your GPU with a real WebGL2 ray-marching load and watch FPS, frame time and stability hold up — or drop off.