CPU Benchmark

CPU Benchmark - Test Your Processor Performance

A comprehensive online CPU benchmarking tool that measures single-thread JavaScript throughput across six workloads: prime number calculation, sorting, recursive Fibonacci, matrix multiplication, hashing and floating-point math. All tests run on the main thread (no Web Workers), so this captures per-core JS performance, not aggregate multi-core throughput. Results stay 100% in your browser and can be exported to CSV or JSON so QA labs and repair technicians can record a baseline before a repair and prove before/after regressions on the same device.

How does CPU benchmarking work?

CPU benchmarking measures processor performance by running standardized computational tasks:

1. Prime Numbers: Tests integer calculations and loops
2. Sorting: Evaluates algorithm efficiency and cache performance
3. Fibonacci: Measures recursive function performance
4. Matrix Operations: Tests mathematical computation speed
5. Hash Calculations: Evaluates string processing
6. Floating Point: Tests decimal number calculations

Each test runs independently and is timed. The score is calculated based on operations per second, with higher scores indicating better performance.

What factors affect CPU benchmark scores?

Several factors influence benchmark results:

- CPU Clock Speed: Higher GHz = faster calculations
- Number of Cores: More cores help with parallel tasks
- CPU Architecture: Newer designs are more efficient
- Browser Performance: JavaScript engine optimization
- Background Processes: Other apps consuming CPU
- Thermal Throttling: Overheating reduces performance
- Power Settings: Battery saver mode slows CPU
- Operating System: Different OS have different overhead

For accurate results, close other applications and ensure your device is plugged in (for laptops).

Why test CPU performance in browser?

Browser-based CPU benchmarks offer several advantages:

- No Installation: Run tests immediately without downloads
- Cross-Platform: Works on Windows, Mac, Linux, mobile
- Safe: Runs in sandbox, can't harm your system
- Accessible: Test any device with a web browser
- Quick: Get results in seconds
- Shareable: Easy to compare results with others

While not as comprehensive as native benchmarks like Cinebench or Geekbench, browser tests provide a good indication of relative CPU performance, especially for web-based workloads.

How to interpret benchmark scores?

Understanding your benchmark results:

- Per-test Score: operations per second for that workload (higher = faster). Each test measures something different, so its ops/s are only meaningful within that test.
- Lower Time = Faster Completion
- Overall Score: a UNITLESS composite index, not ops/s. It is the geometric mean of the six per-test scores normalized to a fixed reference machine and scaled so that reference scores about 1000. A score of 2000 means roughly twice the reference; 500 means about half.

There are no absolute tiers: the index is only comparable on the same browser and device. A given chip will score differently in Chrome, Firefox and Safari (different JS engines), so always compare runs captured under the same conditions. Run two or three times and use the median to smooth out background noise and timer coarsening.

Does this test single-core or multi-core?

This benchmark measures SINGLE-THREAD performance only. Every test runs synchronously on the page's main thread and does NOT use Web Workers, so it does not exercise multiple cores in parallel.

What the per-test score reflects is the speed of one core executing JavaScript: integer math, branch-heavy loops, recursion, cache behaviour and floating-point work. The number of logical cores is shown for reference (Hardware Concurrency) but does not raise the score.

If you need true multi-core/parallel throughput (video rendering, 3D, code compilation), use a native tool such as Cinebench, Geekbench multi-core, or a worker-based stress test. For per-core JS performance and quick before/after comparisons on the same machine, this single-thread test is the right instrument.

Why do scores differ between Chrome, Firefox and Safari?

Because each browser ships a different JavaScript engine, and this is a JavaScript benchmark:

- Chrome and Edge use V8
- Firefox uses SpiderMonkey
- Safari uses JavaScriptCore (JSC)

Each engine has its own JIT compiler, inlining heuristics, garbage collector and math intrinsics, so the SAME chip can score noticeably differently across browsers. A workload that V8 optimizes aggressively may run slower under JSC, and vice versa.

The practical rule: scores are only comparable when the browser, version and device are held constant. For an apples-to-apples before/after-repair comparison, capture both runs in the same browser and export them so the engine and version are recorded in the JSON.

How do I read each individual test?

Each workload stresses a different part of the CPU, which helps localize a slow result:

- Prime Numbers: integer ALU and tight branch-heavy loops (trial division). Sensitive to branch prediction.
- Sorting (QuickSort): memory access patterns and cache behaviour over a large array, plus comparison/swap throughput.
- Fibonacci (recursive): function-call and recursion overhead — call/return, stack frames, the interpreter/JIT call path.
- Matrix Multiplication: dense nested loops with cache locality and multiply-accumulate; sensitive to cache size and memory bandwidth.
- Hash: string traversal and integer bit operations (shifts, adds).
- Floating Point: the FPU and transcendental math (sin, cos, sqrt, divides).

If one test is far below the others on a machine you trust, that points at the corresponding subsystem (cache, FPU, branch-heavy integer work).

Are results private and reproducible?

Privacy: 100% client-side. Every computation runs in your browser; no scores, parameters or device details are ever uploaded to a server. The Copy / Export CSV / Export JSON buttons build the file locally from data already on the page.

Reproducibility: a single run is noisy because performance.now() is coarsened and the tab can be throttled when backgrounded. For a defensible result, keep the tab focused, plug the laptop in, run two or three times and take the median. The exported JSON records the exact parameters used plus the device profile (cores, memory, platform, user-agent hints), so a run can be reproduced and audited later — ideal for attaching numbers to a repair ticket and proving a before/after-repair regression.

Why are my scores lower than expected?

Several reasons can cause lower scores:

1. Background Apps: Close other programs
2. Browser Throttling: Try a different browser
3. Power Saving Mode: Switch to high-performance mode
4. Thermal Throttling: Ensure good cooling
5. Old Browser: Update to latest version
6. Mobile Device: Phones score lower than desktops
7. Virtual Machine: VMs have performance overhead
8. Browser Extensions: Disable unnecessary extensions

For best results:
- Close all other tabs and applications
- Plug in laptop (don't run on battery)
- Ensure good ventilation
- Use latest Chrome, Firefox, or Edge
- Wait for CPU to cool between tests

How accurate is browser-based benchmarking?

Browser benchmarks are reasonably accurate for:

- Relative Comparisons: Comparing CPUs side-by-side
- Web Performance: How fast web apps will run
- JavaScript Workloads: Node.js, web development
- Quick Diagnostics: Identifying performance issues

Limitations:
- Browser overhead affects scores
- Single-threaded in some tests
- No direct hardware access
- Affected by JavaScript engine differences

For professional CPU testing, use native tools like:
- Cinebench R23
- Geekbench 6
- CPU-Z
- PassMark

But for quick, free, no-install testing, browser benchmarks provide valuable insights.

Can I benchmark mobile CPUs?

Yes! This tool works on mobile devices:

- Smartphones (iOS, Android)
- Tablets (iPad, Android tablets)
- Chromebooks
- Any device with a modern browser

Mobile CPU considerations:
- Scores will be lower than desktops
- Thermal throttling is more aggressive
- Background apps have bigger impact
- Battery mode significantly affects performance

For mobile testing:
1. Close all background apps
2. Ensure device is not overheating
3. Use landscape mode for tablets
4. Plug in for best performance
5. Use latest Safari (iOS) or Chrome (Android)

Mobile CPUs are optimized for efficiency over raw performance, so lower scores are normal.

Key Features

• 6 comprehensive single-thread CPU benchmark tests
• Real-time performance monitoring
• Single-thread JavaScript throughput (no Web Workers)
• Operations per second per workload
• Individual test timing and scoring
• Unitless composite index (geometric mean vs reference)
• Export session to CSV and JSON for QA documentation
• Copy full device + benchmark profile to clipboard
• Modern device detection (userAgentData, device memory)
• Prime number calculation test
• Sorting algorithm performance test
• Fibonacci sequence calculation
• Matrix multiplication test
• Hash calculation benchmark
• Floating-point operations test
• CPU information display (cores, memory, platform)
• Visual progress indicators
• Color-coded status (pending/running/completed)
• Stop benchmark anytime
• Reset and re-run tests
• 100% client-side - no data uploaded
• Works offline
• No registration required
• Mobile and desktop support
• Dark mode compatible