CPU Benchmark Online

The CPU benchmark runs five JavaScript sub-tests that target different processor capabilities. Integer Math performs 10 million integer additions to measure raw integer throughput. Float Math executes 5 million sin/cos operations to measure floating-point unit (FPU) performance. Prime Sieve runs the Sieve of Eratosthenes up to 100,000 to measure memory access patterns and cache efficiency. Fibonacci computes the 35th Fibonacci number recursively to measure function call overhead and stack performance. JSON runs 1,000 parse/stringify cycles to measure serialization performance relevant to web APIs.

JavaScript runs inside a virtual machine (V8, SpiderMonkey, or JavaScriptCore) that must JIT-compile code at runtime. This adds overhead compared to pre-compiled native code. JavaScript also has restrictions like no direct memory management and mandatory garbage collection, which can interrupt execution. Modern JavaScript engines are highly optimized and can approach native performance for specific patterns, but are typically 2–5x slower than equivalent C++ for compute-intensive tasks.

These specific tests are single-threaded and only measure the performance of one CPU core. Multi-core CPUs do not improve these scores unless the browser assigns the JavaScript thread to a high-performance core automatically. On hybrid architectures (like Intel P+E cores or ARM big.LITTLE), the browser may run on an efficiency core at lower clock speed, producing lower scores. Web Workers can be used to run JavaScript on multiple cores, but that is not implemented in this benchmark.

The recursive Fibonacci(35) test measures function call overhead, stack performance, and branch prediction. The naive recursive implementation makes approximately 29 million recursive calls to compute fib(35). This tests how efficiently the JavaScript engine handles deep call chains and whether it can optimize tail calls or inline small functions. Modern JIT compilers handle this well, but the test reveals differences in call stack implementation across engines.

The Sieve of Eratosthenes up to 100,000 is a relatively small computation. The implementation uses a Uint8Array (typed array) which allows the JavaScript engine to work directly with raw memory without boxing values as JavaScript objects. Typed arrays are a significant optimization for numeric workloads and can approach native code performance. This test specifically measures how well the engine handles typed array access patterns.