About SpeedPower.run

The Mission

We built SpeedPower.run out of frustration. Existing browser benchmarks focus on isolated metrics-evaluating the JavaScript engine, rendering performance, or basic AI inference separately. They are too synthetic and disconnected from the real-world challenges of the modern web.

Real web applications are increasingly complex. They perform heavy pre/post-processing, run multiple AI models, and handle critical rendering—simultaneously.

Our mission is simple: to create the definitive benchmark for real-world compute performance on the modern web. A tool that is free, open in spirit, and built for a community of developers who, like us, are obsessed with performance.

How it Works

SpeedPower.run calculates a score to determine the maximum performance of a browser or device by pushing all CPUs and GPUs to their limit. Unlike other tools that benchmark a single task, we execute multiple tasks simultaneously—for example, running concurrent AI inferences while handling heavy JS processing. We utilize every available technology: JavaScript, WASM, WebGL, and WebGPU.

The Benchmarks

SpeedPower.run is composed of several benchmarks to cover the real-world compute performance use cases of a modern web application: Core & Communication

Core & Communication

Javascript

This benchmark measures raw computational power for pre/post-processing on JS objects and JSON. It utilizes four tests from the Apple/WebKit JetStream 2 suite: Access Binary Trees, Control Flow Recursive, Regexp DNA, and String Tag Cloud. We run these benchmarks in parallel across multiple Web Workers to measure the maximum multi-core CPU processing power.

Exchange

Since modern apps rely on Web Workers, the "Exchange" benchmark measures the communication bottleneck between the main thread and workers. It tests the transfer speed of IPC, Transferables, Arrays, Buffers, Objects, and OffScreen Canvas. The higher the score, the more efficiently your main thread communicates with background workers.

AI Benchmarks: TensorFlow.js

We utilize TensorFlow.js to test the maturity and performance of established web AI pipelines.

AI TFJS Recognition

Measures the steady-state inference throughput of the BlazeFace model (via TensorFlow.js). Using a 128x128 input tensor and a pre-warmed graph, this test isolates the raw performance of the backend (JavaScript, WASM, WebGL, or WebGPU). It specifically measures the speed of the forward pass and the subsequent interpretive post-processing (decoding the highest-confidence face detection).

AI TFJS Classify

This benchmark measures the throughput of the MobileNetV3 Small architecture. Using a fixed 224x224 input tensor and a pre-warmed graph, this test isolates the raw performance of the backend (JavaScript, WASM, WebGL, or WebGPU). It specifically measures the speed of the forward pass and the subsequent interpretive post-processing (decoding the highest-confidence score).

AI Benchmarks: Transformers.js v3

SpeedPower.run pushes the boundaries of next-gen in-browser AI by leveraging Transformers.js v3 for our most advanced workloads.

AI Transformers Classify

Measures the throughput of the MobileNetV4-Small architecture (via Transformers.js v3). It prioritizes a high-performance WebGPU backend (falling back to WebGL) with a fixed 224x224 input tensor. This score reflects the system's capacity for parallel inference, leveraging asynchronous command queues and compute shaders to process workloads with high concurrency.

AI Transformers LLM

Measures the throughput of the SmolLM2-135M-Instruct causal language model (via Transformers.js v3). Using a 4-bit quantized (q4) ONNX model, this benchmark isolates the GPU runtime efficiency from model loading overhead. It captures the hardware's ability to orchestrate multi-threaded LLM execution and real-time autoregressive decoding.

AI Transformers Speech

Measures the throughput of the Moonshine-Tiny automatic speech recognition (ASR) architecture. It uses a hybrid-precision model (FP32 encoder + q4 decoder) to isolate GPU runtime efficiency from audio processing overhead. The score highlights the capacity for complex, high-concurrency speech-to-text pipelines.

Score Computation

Benchmark Score

We compute a specific score for each benchmark. If a benchmark cannot be executed (e.g., missing WebGPU support, no available Web Workers, or OS memory constraints causing a reload), the score will be 0.

Overall Score

The overall score is the geometric mean of the five benchmark scores. We assign a weight of 6 to Javascript and Exchange, a weight of 3 for each Tensorflow.js benchmark, and a weight of 2 for each Transformers.js benchmark.

Methodology & Integrity

To ensure SpeedPower.run serves as a reliable standard for hardware/browser comparison, we adhere to strict execution protocols:

• Zero Network Interference: Although the benchmark requires downloading ~400MB of data (AI models and assets), the timer does not start until all assets are fully downloaded and loaded into memory. The score purely reflects computational performance, not internet bandwidth.
• Warm-up Execution: To guarantee we measure peak throughput rather than initialization overhead, every benchmark undergoes a preliminary "warm-up" run. This ensures that JavaScript JIT optimization is complete, GPU shaders are compiled, and caches are primed before the official scoring timer begins.
• Score Stability: Because running concurrent workloads (AI + JS + Rendering) can be subject to operating system scheduling noise, we do not rely on a single snapshot. We perform regression analysis on the peak performance metrics for each benchmark during the run.
• Getting the maximum score: Due to some browser and operating system dynamic configurations not under our control some score results may vary. To be sure you get the maximum score for your device, you should run the benchmark several times.

Get in Touch

This project lives and breathes on feedback. For suggestions, questions, or just to talk performance, feel free to reach out at speedpower@scaledynamics.com .