What We Measure

Web Bench uses 8 categories and dozens of detailed tests to see how your device performs inside the browser. Below you can check what each category measures, how it relates to everyday experience, and whether a higher or lower number is better. Tests your device or browser does not support are skipped automatically, and every value is a reference that varies by environment.

CPU single-core

CPU Single measures how fast one core finishes real-world work such as text processing, JSON parsing, compression, hashing, image processing, sorting, pathfinding, physics simulation, ray tracing and linear algebra. Page loading, app responsiveness and programs that do one thing at a time tend to feel close to this value. The unit is operations per second, so higher means more work done in the same time. Tests that need browser APIs such as AES-GCM or Deflate are skipped when unsupported, and the score is calculated from the remaining tests.

Text processing · Single: Tokenization and regular expression search/replace
JSON · Single: Large document parsing and serialization
LZ compression · Single: In-house LZ compression and decompression
SHA-256 · Single: JavaScript hash throughput
Image processing · Single: Gaussian blur, resize and color conversion
Sorting and data structures · Single: Sort, hash map and priority queue
A* pathfinding · Single: Shortest path through a large grid with obstacles
Physics simulation · Single: n-body gravity and elastic collisions
CPU ray tracing · Single: Sphere scene rendering
Linear algebra · Single: Matrix multiplication and partially pivoted LU decomposition
Large integers · Single: BigInt multiplication and 64-bit primality test
Document parsing · Single: Markup tokenization and tree construction
AES-GCM · Single: SubtleCrypto encryption and decryption
Deflate · Single: CompressionStream compression and decompression

CPU multicore

CPU Multi runs the same kind of work split across several Workers to measure throughput when cores work together. You notice the difference in video encoding, large file processing and when running many tabs and apps at once. The unit is operations per second and higher is better. However, results depend on how many Workers the browser uses and how it synchronizes them, so do not read them purely as a physical core count. Tests that rely on encryption or compression APIs are skipped where those APIs are unavailable.

Text processing · Multi: Tokenization and regular expression search/replace
JSON · Multi: Large document parsing and serialization
LZ compression · Multi: In-house LZ compression and decompression
SHA-256 · Multi: JavaScript hash throughput
Image processing · Multi: Gaussian blur, resize and color conversion
Sorting and data structures · Multi: Sort, hash map and priority queue
A* pathfinding · Multi: Shortest path through a large grid with obstacles
Physics simulation · Multi: n-body gravity and elastic collisions
CPU ray tracing · Multi: Sphere scene rendering
Linear algebra · Multi: Matrix multiplication and partially pivoted LU decomposition
Large integers · Multi: BigInt multiplication and 64-bit primality test
Document parsing · Multi: Markup tokenization and tree construction
AES-GCM · Multi: SubtleCrypto encryption and decryption
Deflate · Multi: CompressionStream compression and decompression

Memory

Memory looks at the throughput of reading, writing and copying a contiguous 16 MB block, along with the latency of chasing data through random access. It relates to heavy data movement such as editing large images or video, keeping many tabs open and loading games. Throughput is in GB/s, so higher is better, while random access latency is in ns, so lower is better. Because access sizes are varied, you can also tell where speed changes across the cache hierarchy.

Sequential read: 16 MB sequential memory throughput
Sequential write: 16 MB sequential memory throughput
Sequential copy: 16 MB sequential memory throughput
Random access · 16 KB: Dependent pointer chasing across cache levels
Random access · 64 KB: Dependent pointer chasing across cache levels
Random access · 256 KB: Dependent pointer chasing across cache levels
Random access · 1 MB: Dependent pointer chasing across cache levels
Random access · 4 MB: Dependent pointer chasing across cache levels
Random access · 16 MB: Dependent pointer chasing across cache levels
Random access · 64 MB: Dependent pointer chasing across cache levels
Random access · 256 MB: Dependent pointer chasing across cache levels

GPU graphics

GPU Graphics renders large numbers of triangles, 131,072 particles and bloom and blur post-processing off-screen and measures the average FPS. It relates to how smoothly web games, 3D maps and effect-heavy pages run. The unit is FPS and higher is better. If WebGPU is unavailable, the test may run on the WebGL2 path instead, and if neither is available this category is skipped.

Many triangles: Offscreen graphics rendering · average FPS
131,072 particles: Offscreen graphics rendering · average FPS
Bloom and blur post-processing: Offscreen graphics rendering · average FPS

GPU compute

GPU Compute measures speed when you hand calculations, not graphics, to the GPU. It runs f32 and f16 matrix multiplication, image convolution, particle simulation and parallel sums, and also verifies that the result buffers are correct. It is closest to heavily parallel work such as in-browser video processing and AI inference. Matrix multiplication is shown in GFLOPS and the rest in elements processed per second, and higher is better for all of them. Without WebGPU or the shader-f16 feature, the affected tests are skipped.

Matrix multiplication f32: WebGPU compute · output buffer validation
Matrix multiplication f16: WebGPU compute · output buffer validation
Image convolution: WebGPU compute · output buffer validation
Particle simulation: WebGPU compute · output buffer validation
Parallel sum (reduction): WebGPU compute · output buffer validation

Browser

The Browser category measures DOM manipulation and layout, Canvas 2D drawing, screen refresh rate and frame consistency. It maps directly to everyday experience such as how responsive a complex web app feels and how smooth scrolling and animation are. DOM and Canvas are in operations per second, so higher is better, while frame intervals are in ms, so lower is better. These tests depend heavily on the browser engine and display settings as well as hardware, so compare results within the same browser.

DOM manipulation and layout: Create and update a virtual list, then resolve layout
Canvas 2D: Paths, shapes and text drawing
Refresh rate and frame consistency: requestAnimationFrame intervals · refresh rate and p95 deviation

Storage

Storage creates a temporary file in the browser's OPFS to measure sequential write, sequential read, random write and random read speed, then deletes the file when finished. It relates to downloading large files and loading offline app data. The unit is MB/s and higher is better. If the browser does not support OPFS or it is blocked, for example in a private browsing mode, this category is skipped.

Sequential write: Temporary OPFS file I/O · deleted afterwards
Sequential read: Temporary OPFS file I/O · deleted afterwards
Random write: Temporary OPFS file I/O · deleted afterwards
Random read: Temporary OPFS file I/O · deleted afterwards

AI inference (optional)

AI inference is optional and runs only if you agree to download the models. It feeds fixed test sentences and images to measure how fast text generation and image models run inside the browser, and it never uses your personal files. It is a reference for how smooth on-device AI features might feel, and a higher processing speed is better. If you do not agree, it is not run and is left out of the total score. If WebGPU is unavailable it runs on the WASM path instead, and that is shown separately.

Time to first token: From generate call to first token · excludes tokenization
Prompt processing: Input tokens / first forward pass · excludes tokenization and sampling
Text generation: greedy 128 tokens · throughput of 127 tokens after the first
Single-image classification: Fixed 224×224 RGB image · excludes preprocessing · MobileNetV4 fp32