GPU Stress Test - Volume Shader BM Benchmark Platform Background
Volume Shader BM - GPU Benchmark Platform

FREE ONLINE GPU STRESS TEST

No installation or account is required. Calculations run on your device after you select Start test. Temperature and GPU utilization are unavailable in this browser test.

Benchmark Preview

READY TO TEST

Click Start to Benchmark

Important Information

  • Tests may cause older devices to slow down or become unresponsive.
  • Close other applications before running the tests for accurate results.
  • Results may vary depending on your device's current load and temperature.

Environment & Performance

API:WebGL 1.0
Browser:Unknown
Limits:Detecting...
GPU:Detecting GPU...
OS:Unknown

Performance Metrics

FPS (current)0
FPS sample 1st percentile0
Estimated frame interval0 ms
Sample-to-average FPS ratio--
FPS (avg)0
FPS min0
FPS max0

Performance Testing

Volume shader basic
Essential
Volume shader basic
A WebGL fragment shader draws a procedural scene by ray marching. Use the same camera and shader to compare frame rates; editing the shader changes the workload.
Volume shader benchmark
Popular
Volume shader benchmark
This editable WebGL shader demo renders a procedural volume. Compare the same code, camera, and viewport before and after a change; it does not produce a standardized hardware score.
GPU shader stress test
Heavy Load
GPU shader stress test
A WebGL 2 fragment shader repeats mathematical work at selectable stress levels for a timed run. Results include sampled FPS and a frame consistency index; no temperature or utilization sensor is read.
Canvas animation test
Canvas animation test
JavaScript animates shapes and Canvas 2D draws them. The demo adjusts object counts with performance. Compare object count together with FPS to study animation capacity, not isolated GPU speed.
Canvas particle test
Canvas particle test
JavaScript updates moving particles and Canvas 2D draws them. Particle count, size, and speed change the workload. Observe motion and FPS; there is no GPU compute or hardware memory measurement.
Canvas texture test
Canvas texture test
Images are generated on temporary 2D canvases and drawn as animated textures. The displayed memory figure estimates image pixel storage; it is not physical VRAM usage or measured memory bandwidth.
CPU Web Worker demo
CPU Web Worker demo
JavaScript workers repeatedly execute a small mathematical loop while a 2D canvas visualizes their progress. Completed iterations and worker count describe this CPU demonstration, not GPU compute throughput.
WebGL ray tracing demo
WebGL 2
WebGL ray tracing demo
A fragment shader calculates ray intersections and shading in WebGL 2. Adjust rays or bounces to compare the same scene; dedicated hardware ray-tracing cores are not tested.
JavaScript physics demo
JavaScript physics demo
JavaScript updates moving circles and checks pairs for collisions, with Canvas 2D drawing the scene. Increasing object count increases collision work; FPS reflects CPU simulation plus drawing.
WebGL visual effects test
WebGL visual effects test
A WebGL 2 fragment shader combines procedural visual effects. Change effect count, intensity, or quality one at a time; this is a synthetic shader workload rather than a production post-processing pipeline.
WebGL shadow mapping test
WebGL shadow mapping test
WebGL 2 renders a depth texture and filters it to shade a scene. Changing shadow quality changes map size and sampling. Compare FPS and shadow appearance under the same lighting settings.
WebGL instancing test
WebGL instancing test
WebGL 2 draws many triangle instances using an instanced draw call. Increase the instance count while holding the viewport fixed to observe frame-rate changes; results are specific to this simple geometry.
WebGL texture compute demo
Advanced
WebGL texture compute demo
WebGL 2 fragment shaders update particle state in alternating framebuffer textures, then draw the particles. This uses rendering passes rather than WebGPU compute shaders and reports browser FPS, not TFLOPS.
WebGL texture readback check
Memory Check
WebGL texture readback check
This tool allocates 1024×1024 RGBA textures, writes a shader pattern, then compares sampled bytes from two readbacks. It checks readback consistency, not every physical VRAM cell or memory bandwidth.

Testing methodology

Browser tests measure a particular workload on a particular browser. This guide explains how to repeat a run and interpret its limits.

What the numbers measure

FPS counts browser animation callbacks per second. It includes JavaScript, rendering, and browser scheduling. Frame consistency is an index calculated from FPS variation, not a hardware health certificate. A display refresh limit can cap FPS even when the GPU has spare capacity.

A repeatable comparison

Use the same browser version, viewport, zoom, power mode, and workload settings. Close competing tasks, keep the tab visible, allow a short warm-up, then repeat three times. Change one variable at a time; record all results rather than choosing the highest.

Keep a run record

Record the date, browser and OS versions, renderer if available, viewport, workload settings, duration, and FPS readings. Read temperature and clock speed separately with a supported hardware monitor.

This site cannot read GPU temperature, power draw, clock speed, or utilization through WebGL. Use a separate hardware monitor for those readings. A successful run does not guarantee stability in games, rendering software, or other workloads.

Testing methodology

From the Blog

Guides, benchmarks, and tips for testing and tuning your graphics card.

View all articles
June 28, 20262 min read

GPU Compute, Web Workers, and Shader Demos: What Is Actually Measured?

Distinguish CPU Web Workers from WebGL rendering passes and choose measurements that answer a real GPU compute question.

GPU ComputeGPGPUCompute Benchmark
Read more
June 25, 20262 min read

How to Investigate Low FPS Without Guessing the Bottleneck

Compare fixed workloads, separate browser scheduling from game performance, and collect evidence before blaming the GPU.

Low FPSBottleneckCPU vs GPU
Read more
June 22, 20262 min read

How to Run WebGL Tests and Troubleshoot a Blank Canvas

Start browser graphics tests deliberately, distinguish WebGL from Canvas and workers, and investigate unsupported features or context loss.

WebGL BenchmarkBrowser GPU TestNo Install
Read more

GPU Stress Test FAQ

Answers about browser graphics tests, FPS interpretation, and common problems.

A WebGL 2 fragment shader repeats mathematical work at selectable stress levels for a timed run. Results include sampled FPS and a frame consistency index; no temperature or utilization sensor is read.

A WebGL fragment shader draws a procedural scene by ray marching. Use the same camera and shader to compare frame rates; editing the shader changes the workload.

Save your work, close competing apps, and keep the device ventilated. Use a current browser with hardware acceleration where available. Start with a short run and modest settings. Stop if the device becomes unresponsive or displays unexpected glitches.

A steady low FPS can simply mean a demanding workload. High FPS at a display refresh limit does not prove maximum GPU performance. Compare repeated runs with identical settings; differences between browsers also include their rendering engines.

No installation or account is required. Calculations run on your device after you select Start test.

A blank canvas or context loss can result from unsupported WebGL, browser memory limits, a driver reset, or software rendering. Reduce the workload and retry. Reproduce a problem in another application before drawing a hardware conclusion.

Start with the defaults. Observe FPS and the workload count for 30–60 seconds. Where configurable, change only Stress Level, then repeat under the same conditions. Some demonstrations adapt their workload automatically; compare both the workload count and FPS. Stop with the button or Escape.