Skip to main content
GPU Testing

Volume Shader Test

Run a real-time volumetric shader workload and observe rendering performance, frame timing, and visual stability directly in your browser.

GPU ShaderBrowser-BasedReal-TimeNo Download
Honest Hardware DisclosureGLSL 3.00 ES

This tool performs real volumetric shader rendering through WebGL2. Browser security restrictions prevent access to low-level GPU information such as exact temperature, power draw, or clock speed. We report verified driver context parameters and exact measured frame timing only — no synthetic or estimated data.

Optimal Testing Conditions
  • Keep this browser tab focused
  • Close GPU-heavy 3D/video tabs
  • Plug in laptop wall charger
0.0 FPS
Frame: 0.0 ms
Volumetric Ray Marching

Ready to Test

Run a real-time volumetric shader workload and measure rendering performance, frame timing, and stability.

Volume Shader Configuration

Customize volumetric ray-march steps, procedural noise octaves, density, and light attenuation.

Status: IDLE00:00.0
Volume ComplexityControls procedural 3D noise octaves calculated per ray march step.High (3 Octaves)

Controls mathematical noise fractal octaves per step.

Ray March StepsNumber of ray-marching sample evaluations along each camera ray.96 Steps

Higher steps increase visual clarity and GPU shader load.

Volume DensityControls volume optical thickness and Beer-Lambert absorption.Medium (Balanced)

Controls volumetric optical thickness and absorption.

Lighting ComplexityControls secondary shadow ray marching and forward scattering.Medium (Shadow March)

Secondary shadow rays and Henyey-Greenstein scattering.

Render ScaleInternal WebGL2 drawing buffer resolution multiplier.100% (Native DPR)

Controls the internal canvas rendering resolution.

Test Duration30 Seconds

Select benchmark duration or continuous run.

Live FPSCurrent rendered frames per second for volumetric ray marching.
0.0
Current frame rate
Avg FPSAverage performance across all frames rendered during the test duration.
0.0
Session aggregate
1% Low FPSFrame rate during the slowest 1% of frames. Highlights micro-stutters and shader stalls.
0.0
99th percentile slowest
Frame TimeMilliseconds between rendered frames while the volume workload runs. This is wall-clock frame interval measured with performance.now(), not isolated GPU execution time.
0.0 ms
Render interval
JitterMean frame-to-frame variance in milliseconds. Lower indicates steadier pacing.
0.0 ms
Frame time variance
StabilityPercentage of frames delivered within ±20% of the mean interval.
--%
Pacing rating
Ray March Steps96
Volume ComplexityHIGH
Shader Passes2
Render Scale100%
WebGL VersionWebGL 2.0

Real-Time Frame Rate (FPS)

Cur: 0.0Avg: 0.0Peak: 0.0
60 FPS Target35 FPS15 FPS
Hover over timeline to inspect frame
Sliding Window (Last 80 frames)

Frame Delivery Time (ms)

Cur: 0.0 msAvg: 0.0 msTarget: 16.6 ms
16.6ms Target (60Hz)33.3ms (30 FPS)
Hover over timeline to inspect frame
Lower is smoother

Graphics Hardware & Context Parameters

Parameters queried directly from your browser's WebGL 2.0 graphics driver context.

WebGL 2.0 Active
Unmasked GPU Renderer:Detecting...
Unmasked GPU Vendor:Detecting...
Display Pixel Ratio (DPR):1.0
Max Viewport Dimensions:-- x --
Max Texture Dimension:-- px
Max Fragment Uniforms:--
Max Vertex Uniforms:--
Hardware API Standard:W3C WebGL 2.0 / GLSL ES 3.0
Source: Browser W3C WebGL2 & WEBGL_debug_renderer_info interfacesDirect Driver Query

Understanding Volume Shader Performance

Learn how GPU ray marching works, what step counts reveal about compute limits, and why volumetric media stresses graphics pipelines.

01•TECH OVERVIEW

What is a Volume Shader?

A volume shader computes visual properties for semi-transparent, three-dimensional spatial media such as clouds, smoke, fog, and planetary atmospheres. Unlike standard 3D mesh rendering that only calculates color at the surface polygon, a volume shader computes density, light absorption, and in-scattering at multiple depths inside the volume.

02•ALGORITHM

What is Ray Marching?

Ray marching is a numerical rendering technique where a virtual camera ray steps forward incrementally through 3D space. At each step along the ray, the fragment shader samples mathematical noise equations, evaluates local matter density, and accumulates light attenuation until the ray exits the bounding volume or becomes fully opaque.

03•GPU WORKLOAD

Why Volumetric Effects Demand High GPU Power

In surface rendering, each screen pixel often executes a fragment shader once. In volumetric ray marching, every single screen pixel executes the shader loop dozens or hundreds of times (once per step). At 1080p with 96 steps, your GPU computes over 190 million 3D mathematical samples per frame.

04•PRECISION

What are Ray March Steps?

Ray march steps determine the spatial sampling frequency along the camera ray. Low step counts (32 steps) run faster but can cause visual banding (aliasing). Higher step counts (96 to 192 steps) yield silky smooth volumetric smoke and accurate shadow attenuation at the expense of higher GPU shader core utilization.

05•FILLRATE

What Does Render Scale Do?

Render scale alters the internal drawing buffer resolution before outputting to your display. At 100%, each canvas pixel maps 1:1 with hardware pixels. At 150%, the GPU computes 225% more ray-marched fragments, isolating pixel fillrate bottlenecks and high-density memory bandwidth limits.

06•TIMING

What is Frame Time?

Frame time is the exact duration in milliseconds required by your graphics hardware to compute and deliver a complete frame. While FPS is an aggregate average frequency, frame time reveals the real-world smoothness of each interval (16.67ms corresponds to a steady 60 FPS).

07•STUTTER ANALYSIS

What is 1% Low FPS?

1% Low FPS reflects the average frame rate of the slowest 1% of recorded frames during the benchmark. This highlights periodic shader compilation hitches, thermal throttling events, and driver stalls that high average FPS scores can conceal.

08•HARDWARE COMPARISON

Why Two GPUs Produce Different Results

Volumetric ray marching depends heavily on fast floating-point arithmetic (ALU compute), wide SIMD execution units, and high L1/L2 cache hit rates. Dedicated gaming graphics cards with thousands of shader cores will significantly outpace integrated mobile or low-power laptop silicon.

Frequently Asked Questions

Common questions regarding WebGL2 volumetric shader ray marching, hardware limits, and GPU performance.

A Volume Shader Test is a GPU benchmark that evaluates hardware graphics performance by executing intensive volumetric ray-marching algorithms inside a real-time WebGL2 fragment shader.
It tests your graphics card's shader multiprocessors, floating-point arithmetic throughput, branch execution efficiency, and procedural mathematical calculation speed under continuous volumetric light scattering workloads.
Ray marching is a numerical technique where the shader casts rays into a 3D volume and takes discrete sampling steps along the ray path to calculate density, light extinction, and color accumulation.
Every step multiplies the mathematical workload per pixel. Increasing from 32 to 128 steps quadruples the number of procedural noise evaluations and light calculation loops executed across all display fragments.
Volumetric rendering visualizes 3D spatial fields without hard surface polygons, accurately simulating natural phenomena like nebula clouds, atmospheric haze, dense smoke, and radiant light shafts.
Yes. WebGL2 compiles GLSL source code directly into your GPU driver's native machine instructions. All calculations execute directly on your physical graphics hardware execution units.
Yes, provided the browser and device support WebGL2. On integrated graphics (Intel Iris, AMD Radeon Graphics, or Apple Silicon), select 32 or 64 steps for optimal stability.
Different browsers use different WebGL translation backends (DirectX ANGLE on Windows Chrome/Edge vs native Metal on macOS Safari or OpenGL on Linux). Driver optimizations and compositor overhead vary between browser engines.
No. Web standards enforce security boundaries that prevent websites from accessing hardware thermal diodes or motherboard telemetry. Any browser tool displaying temperature without native desktop companion software is fabricating numbers.
As the volumetric camera orbits and internal density fields oscillate, the number of ray steps intersecting high-density regions changes. Heavy light absorption and shadow ray steps fluctuate dynamically with camera orientation.
Yes. Because our benchmark uses deterministic procedural noise seeds and identical math algorithms, running the same preset (e.g., 96 steps, 100% scale, 30s) produces a consistent, repeatable workload for hardware comparison.
Yes dramatically. Scaling up to 150% super-samples pixels, forcing the GPU to compute 2.25x more ray-marched fragments, stressing pixel fillrate and memory bandwidth.

Related Hardware & Graphics Tools