Benchmark catalog

Each card opens a runnable page. Read the safety notes, then start the timer or live view that matches the hardware you are evaluating.

Shaders & volumetrics

Entry volumetric shader scene

Orbit a compact implicit surface rendered with ray-style stepping in the fragment stage—friendly on more GPUs while still showing how volume-like shading scales.

What this lighter volumetric path shows

Implicit surface shaded with dynamic lighting inside the shader
Tiered kernel and step counts so phones can start low
Live FPS and frame-time readouts
WebGL 1–friendly GLSL for broader hardware reach
Mouse and touch camera controls for desktop or mobile

Run entry volumetric test

Shaders & volumetrics

Advanced volumetric benchmark

A deeper volumetric-style workload with timed segments, geometry detail, and effect stacks—the page many users seek when they want a heavy GPU shader examination on PC or Android.

Heavier volumetric / BM-style stress

Longer timed runs with stability and resolution reporting
Sliders for geometric complexity and post-style effect load
WebGL 2 feature set for modern browsers
Useful for comparing desktop cards and flagship phones under sustained load
Pairs well with the entry volumetric test for before/after tuning

Run advanced volumetric benchmark

Stress

Sustained GPU overload

Layered shader passes and iteration controls meant to hold the graphics pipeline busy—watch for thermal sag on compact devices.

Stress session overview

Configurable duration blocks
Shader weight presets from mild to extreme
Iteration multiplier for extra per-frame work
Live stability percentage alongside FPS
Rough shader-memory estimate for context

Open GPU stress run

Visualization

Animated field visualization

A distinct fullscreen fragment animation—polar waves, palette sweeps, and harmonic stacks—not the same code path as the volumetric implicit-surface tests.

Visualization workload notes

Quality presets stack outer layers and inner micro-samples
Effect presets add long harmonic and warp loops
Reports load index, resolution, and stability
Ideal when you want a non-volumetric shader torture pattern
Complements volumetric pages for a fuller GPU picture

Run field visualization

Particles

Swarm particles

Thousands of simulated points with forces rendered as GPU sprites—CPU integration meets fragment cost as counts climb.

Particle benchmark facts

Adjustable population up to tens of thousands
Tiered physics substeps and forces
Sprite shading scales with the chosen tier
Shows estimated buffer footprint
Good for spotting mobile CPU/GPU balance issues

Launch particle test

Memory & bandwidth

Texture bandwidth pressure

Large RGBA allocations plus chained dependent samples per frame—VRAM size and sampling throughput both matter.

Texture-heavy pass summary

Eight high-resolution textures resident at once
Dozens of fullscreen passes per frame with layered reads
Configurable resolution and active layer count
Timed window with automatic results capture
Highlights bandwidth-bound GPUs quickly

Run texture pressure test

Compute

Parallel numeric kernel (WebGL 2)

Fullscreen fragment kernels emulate dense compute: every pixel runs the same dependent math loop—requires WebGL 2.

Compute-style fragment kernel

Outer iteration slider scales work per pixel
Choose half (mediump) or single (highp) precision
Estimates scalar operations per frame
Shows backend string and framebuffer size
No WebGL 1 fallback by design

Start parallel math test

Rendering

SDF ray march (shader RT, not API RT)

Signed-distance ray marching in GLSL with many fullscreen redraws per frame—measures classic GPU ray stepping, not hardware ray tracing APIs.

Ray-march benchmark

Dense primitive field with floor and sky contribution
Adjustable march-step cap per segment
Optional reflection segments (bounce depth)
Multi-pass per frame multiplies fragment cost
Clear labeling that this is shader-based marching

Open SDF march test

Simulation

2D physics + heavy point shading

JavaScript circle solver paired with repeated point draws and a long fragment program—loads CPU and GPU together.

Hybrid simulation notes

Pairwise collision passes scale with body count tier
Substep control increases integration depth
Sixteen GPU point passes per frame
Fragment shader contains hundreds of dependent trig ops
Exposes main-thread bottlenecks vs fill limits

Run physics hybrid test