Volume Shader BM Benchmark

What is the Volume Shader BM Benchmark?

The Volume Shader BM Benchmark is an established synthetic stress test engineered specifically to quantify raw floating-point arithmetic logic unit (ALU) throughput and fragment shader concurrency in modern graphics processors. Originally popularized in the graphics demoscene and WebGL experimentation hubs, the benchmark discards conventional polygonal rendering techniques in favor of real-time volumetric raymarching.

In traditional 3D rendering pipelines—such as standard video game engines—the vast majority of GPU performance is dictated by vertex transforms, triangle clipping, occlusion culling, and texture memory bandwidth (VRAM caching). In contrast, Volume Shader BM deliberately constructs a computational bottleneck inside the fragment processing units. Every pixel displayed on your monitor requires marching a 3D ray through virtual coordinates, evaluating dense 3D noise functions at continuous intervals, and calculating volumetric transmittance using physical light absorption formulas.

The Mathematics of Volumetric Raymarching & Signed Distance Fields

Understanding how Volume Shader BM pushes GPUs requires examining the mathematical foundations of volumetric rendering. Unlike ray tracing—which calculates discrete ray-surface intersections against polygonal primitives—volumetric raymarching evaluates a continuous density field across empty space.

1. Camera Ray Generation

For each fragment on the screen, a normalized ray vector $\vec{R}_d$ is projected from the camera origin $\vec{R}_o$ through the viewport coordinate:

vec2 uv = (gl_FragCoord.xy - 0.5 * u_resolution.xy) / min(u_resolution.x, u_resolution.y);
vec3 ro = vec3(0.0, 0.0, -1.2);
vec3 rd = normalize(vec3(uv, 1.3));

2. Procedural 3D Noise Field Synthesis

Rather than sampling an externally loaded volume texture, the shader synthesizes an organic fluid nebula by computing multi-dimensional fractal hash interpolations directly in arithmetic registers:

float noise(in vec3 x) {
    vec3 i = floor(x);
    vec3 f = fract(x);
    f = f * f * (3.0 - 2.0 * f); // Hermite cubic curve interpolation
    return mix(mix(...), mix(...), f.z);
}

3. Light Extinction & The Beer-Lambert Law

As the ray marches through the virtual volume, it calculates light transmittance using numerical Riemann integration. According to the Beer-Lambert law, light intensity decays exponentially as it travels through an absorbing medium:

$$T = \exp\left(-\int \sigma_t(x) \, dx\right)$$

In our optimized WebGL fragment shader, this continuous integral is approximated discretely across 64, 128, 256, or 512 steps:

for (int i = 0; i < 512; i++) {
    if (float(i) >= u_steps || sum.a >= 0.98) break;
    vec3 pos = ro + t * rd;
    float den = map(pos);
    if (den > 0.01) {
        float density = clamp(den * 0.35, 0.0, 1.0);
        vec4 colStep = vec4(col, density);
        colStep.rgb *= colStep.a;
        sum += colStep * (1.0 - sum.a); // Front-to-back alpha blending
    }
    t += stepSize;
}

At an execution density of 512 steps at 1080p (1920×1080 = 2,073,600 pixels), the GPU is tasked with evaluating up to 1.06 billion ray steps per frame. At 60 frames per second, this demands over 63 billion procedural noise computations per second, presenting an extreme challenge for even flagship desktop GPUs.

How Different GPU Architectures Handle Volume Shader BM

Because Volume Shader BM is heavily bound by instruction-level parallelism (ILP) and arithmetic intensity, performance characteristics vary significantly across different microarchitectures:

Benchmark Score Matrix & Performance Tier List

The official Volume Shader BM algorithm records average frame rate, minimum 1% frame times, and step complexity to calculate a normalized benchmark index:

Score = Math.round( Average_FPS × (Steps / 64) × 85 × Resolution_Scale )

Standardized Testing Protocol for Repeatable Benchmarking

To achieve scientific repeatability and comparable scores across different machines, follow our recommended standardized testing conditions:

1. Thermal Equilibrium: Ensure your machine is not thermal-throttling prior to starting. Allow your GPU and CPU to idle at normal ambient room temperature (20°C–24°C) for at least 3 minutes before testing.
2. Power Profile: On laptops, verify that the AC power adapter is connected and the operating system power plan is set to "Best Performance" or "High Performance". Battery-saving profiles intentionally throttle GPU core clocks.
3. Eliminate Background Interference: Close streaming applications, hardware-accelerated video tabs (such as YouTube 4K), and secondary 3D software (Blender, Unreal Engine, active games) to ensure dedicated GPU allocation.
4. Default Benchmark Standard: The reference baseline for cross-device comparisons is Heavy (128 Steps) at 1.0x Scale for 20 Seconds.

Browser Optimization & ANGLE Backend Tuning

Because WebGL sits atop the browser's graphics rendering compositor, system and browser configurations can have a profound impact on benchmark results.

Uncapping Frame Rates in Chromium Browsers

By default, Google Chrome, Microsoft Edge, Brave, and Opera sync WebGL presentations with your operating system's desktop refresh rate. If you are using a 60Hz display, your benchmark will never exceed 60 FPS regardless of your GPU's power. To fully evaluate unrestricted performance:

Launch Chrome from your command prompt or terminal with the frame rate limit disabled:

# Windows (Run dialog):
chrome.exe --disable-gpu-vsync --disable-frame-rate-limit

# macOS (Terminal):
open -a "Google Chrome" --args --disable-gpu-vsync --disable-frame-rate-limit

Switching the ANGLE Graphics Backend

On Windows, Chrome communicates with your GPU via the ANGLE abstraction layer. Depending on your GPU vendor, switching the backend API can yield noticeable performance improvements:

• Type chrome://flags into your address bar and press Enter.
• Search for "Choose ANGLE graphics backend".
• D3D11: Most stable baseline for NVIDIA and older Intel hardware.
• D3D11on12 / D3D12: Can deliver improved multi-threaded command recording on Windows 11 with modern AMD and Intel Arc graphics.
• Vulkan: Ideal for Linux workstations and modern Android smartphones.

Diagnosing Performance Bottlenecks & Frame Drops

If your Volume Shader BM benchmark score is lower than expected for your hardware tier, review these common troubleshooting checks:

Frequently Asked Questions