How Our Benchmark Works
Deep technical dive into the ray marching algorithm, Mandelbulb fractals, WebGL shaders, and performance metrics that power our GPU stress test.
Benchmark Overview
Our Volume Shader Benchmark tests GPU performance using ray marching—a computationally intensive technique that renders a Mandelbulb fractal in real-time. Unlike traditional benchmarks that test multiple rendering techniques simultaneously, we isolate volume rendering workloads to provide focused GPU performance data.
The benchmark runs entirely in your browser using WebGL, making it accessible without downloads while still delivering intensive GPU stress. Each frame requires millions of mathematical calculations across thousands of GPU cores, simulating real-world volumetric rendering found in games, scientific visualization, and VFX production.
Why Mandelbulb Fractals?
We chose Mandelbulb fractals for several technical reasons:
- Computational complexity: Each point requires iterative mathematical operations
- No texture memory bottleneck: Fractals are procedurally generated, testing pure compute
- Deterministic workload: Same fractal always produces identical results for comparison
- Scalable difficulty: Iteration count and resolution directly control GPU load
- Visual verification: Render errors are immediately visible in the fractal structure
Ray Marching Algorithm
Ray marching (also called sphere tracing when using distance fields) is the core algorithm that renders our fractal. For every pixel on your screen, the GPU traces a ray from the camera through that pixel into the 3D scene.
Step-by-Step Process
- 1.Cast Ray: From camera position through pixel into the 3D world
- 2.March Forward: Move along ray in steps, sampling the distance field
- 3.Evaluate Fractal: At each step, calculate whether we're inside/outside the fractal
- 4.Detect Surface: When distance changes sign, we've hit the fractal surface
- 5.Binary Search: Refine the exact intersection point with 8 iterations
- 6.Calculate Shading: Compute surface normal, lighting, and final color
This process happens for every pixel, every frame. At 1920×1080 resolution running at 60 FPS, that's over 124 million ray marches per second. Each march requires dozens of steps, each step evaluating the fractal kernel—resulting in billions of calculations per second.
Why This Stresses GPUs
Ray marching is GPU-intensive for multiple reasons:
- ALU-bound: Heavy mathematical operations (trigonometry, power functions, square roots)
- Variable iteration count: Different pixels require different step counts
- No early termination: Can't skip pixels, each must be fully traced
- Register pressure: Algorithm requires many intermediate variables
- No caching: Each frame recalculates everything from scratch
The Mandelbulb Fractal
The Mandelbulb is a three-dimensional analog of the famous Mandelbrot set. While the Mandelbrot set uses 2D complex numbers, the Mandelbulb extends this to 3D using spherical coordinates.
Mathematical Foundation
For each point in 3D space, we iterate a formula that transforms the point using power-8 spherical coordinates:
This iteration repeats (default: 5 times for balanced preset). If the point escapes beyond a threshold, it means that coordinate is outside the fractal. This binary classification creates the fractal's complex surface structure.
Performance Impact of Parameters
Ultra Low: 2 iterations
Balanced: 5 iterations (default)
Very High: 10 iterations
More iterations = more detailed fractal but lower FPS
Ultra Low: 0.25× (256px)
Balanced: 0.95× (972px)
Very High: 1.6× (1638px)
Higher resolution = exponentially more pixels to calculate
Ultra Low: 0.008 (fewer steps)
Balanced: 0.002
Very High: 0.0008 (more steps)
Smaller steps = more accurate but more ray marching work
WebGL Shader Implementation
Our benchmark runs entirely in a fragment shader—a program that executes once per pixel on the GPU. WebGL provides the interface between JavaScript and the GPU, allowing us to compile and run shaders directly in the browser.
Shader Architecture
The rendering pipeline consists of:
- Vertex Shader: Draws a fullscreen quad (2 triangles covering the viewport)
- Fragment Shader: Performs ray marching for each pixel
- Kernel Function: Evaluates the Mandelbulb at a 3D point
- Lighting Calculation: Computes surface normals via finite differences
- Camera Uniforms: Position, direction, and field of view passed from JavaScript
Camera System
The camera continuously orbits the fractal during benchmarking, ensuring consistent workload. User controls (mouse, touch, wheel) allow exploration:
- Left mouse drag / 1-finger touch: Rotate camera (orbits around center)
- Right mouse drag / 2-finger touch: Pan camera (moves center point)
- Mouse wheel / pinch: Zoom in/out (adjusts distance)
- Auto-rotation: 0.01 radians per frame during benchmark
Performance Factors
GPU performance in this benchmark depends on multiple architectural factors:
Higher TFLOPS (trillions of floating-point operations per second) directly correlates with better FPS. The fractal kernel uses intensive math operations that benefit from raw compute power.
Different architectures handle ray marching differently. NVIDIA GPUs often excel at branching code, while AMD GPUs may have higher theoretical TFLOPS but vary in shader optimization.
While our fractal is compute-bound, writing final pixels still requires memory bandwidth. High-end GPUs with faster VRAM (GDDR6X, HBM2) have an advantage at high resolutions.
Sustained workload causes GPU temperature to rise. If cooling is inadequate, the GPU will throttle (reduce clock speed) to prevent overheating, which our SLS metric detects.
Browser WebGL implementation and GPU drivers affect performance. Chrome typically has the best WebGL performance, while some drivers may have shader compilation overhead (measured by TTFF).