Skip to main content

CPU benchmark online

Test your browser's computational performance.

Free & unlimitedWorks offline

System info

Logical cores
2
Device memory
8 GB
Platform
Linux x86_64

Quick presets

About this benchmark

Single-thread tests

Prime sieve, matrix multiply, string operations, and array sort test raw single-core JavaScript performance. Higher scores indicate faster execution.

Multi-thread test

Distributes prime counting across all available CPU cores using Web Workers. Measures parallel speedup and efficiency vs single-threaded baseline.

Crypto throughput

Measures SHA-256 hashing throughput using the Web Crypto API. This tests both CPU and browser crypto implementation speed.

Scoring

Scores are relative and designed for comparing across devices and browsers. Close other tabs and apps for the most consistent results.

All processing happens in your browser. No data is sent to any server.

This CPU benchmark runs six workloads in your browser and scores each on how long it took. Prime sieve counts every prime below 2,000,000 with a Uint8Array sieve. Matrix multiply does a 512 by 512 Float64 product in the cache-friendly i-k-j order. String operations build a 100,000-character string and run 50,000 JSON encode and decode cycles. Array sort orders 2,000,000 doubles. The multi-thread test first times one Web Worker on a trial-division prime count, then splits the same range across one worker per logical core and reports the parallel efficiency. Crypto hashes a 1 KB block with SHA-256 through Web Crypto for three seconds.

Key facts about CPU benchmark online

Key facts about CPU benchmark online
Prime sievesieve of Eratosthenes over a Uint8Array up to 2,000,000, single thread
Matrix multiply512 x 512 Float64Array product, i-k-j loop order for cache locality
String operations100,000 character concatenations plus 50,000 JSON.stringify and JSON.parse round trips
Array sort2,000,000 random Float64 values sorted with a numeric comparator
Multi-thread testone Web Worker per navigator.hardwareConcurrency core, counting primes by trial division
Parallel efficiencysingle-worker time divided by multi-worker time, divided by thread count, as a percentage
Crypto testcrypto.subtle.digest SHA-256 over a 1 KB block for three seconds, reported in MB/s
Score formulaa fixed weight divided by elapsed milliseconds, so higher is faster and scores are relative
PresetsQuick runs everything, plus Single core, Multi core and Memory intensive focus runs
Overall ratingabove 3000 Outstanding, 2000 Excellent, 1000 Good, 500 Average, 200 Below average
Worker deliverythe worker source is a Blob object URL, so no extra file is fetched
Historyprevious runs kept for comparison while the page is open

What happens to your file

Every workload runs as JavaScript in this tab and in Web Workers spawned from a Blob URL created in the same tab. No code is downloaded to run the test, no result is uploaded, and no identifier is stored — the numbers exist in memory while the page is open and disappear when you reload. The only hardware detail read is navigator.hardwareConcurrency, the logical core count, which decides how many workers to spawn. The workers are terminated and their object URL revoked as soon as the multi-thread test finishes, so nothing keeps running in the background afterwards.

About this tool

  1. 1

    Close other work first

    Other tabs, video calls and background sync all compete for the same cores. Close what you can and let the machine idle for a few seconds before starting, or the scores measure your workload rather than your CPU.

  2. 2

    Pick a preset

    Quick runs all six tests. Single core focus runs only the prime sieve, Multi core focus runs only the Web Worker test, and Memory intensive runs only the large array sort.

  3. 3

    Let it finish without switching tabs

    Browsers throttle background tabs. Leaving the page mid-run does not just pause the test, it distorts the timings that are already being measured.

  4. 4

    Read the per-test scores

    Each test has its own bar. A machine can be strong on the sieve and weak on the sort, which tells you more about memory bandwidth and cache than a single combined number would.

  5. 5

    Check the parallel efficiency

    The multi-thread test reports a percentage. Near 100 per cent means the cores scale cleanly; well below that usually means hyperthreading, thermal limits or background load.

  6. 6

    Watch the crypto throughput

    SHA-256 through Web Crypto is normally hardware accelerated, so the MB/s figure reflects the CPU's crypto instructions rather than JavaScript execution speed.

  7. 7

    Run it twice

    The first run often warms caches and lets the JIT compile the hot loops. The second run is usually the more representative one, and a third that drops sharply points at thermal throttling.

Specs & compatibility
Browser supportany browser with Web Workers and Web Crypto — Chrome, Edge, Firefox, Safari, Opera
Secure contextcrypto.subtle requires HTTPS, which this page uses; without it the crypto test cannot run
Core count sourcenavigator.hardwareConcurrency, which reports logical threads and is capped by some browsers
Memory requiredroughly 40 MB peak for the sort and matrix tests; low-memory phones may struggle
Run timeabout 10 to 30 seconds for the full set, depending on the machine
Page responsivenessthe single-thread tests block the main thread, so the tab will not respond while they run
Cross-browser comparisonvalid only within one browser — engines differ enough to change scores on identical hardware
Account or installnone — no signup, no download
  • Scores here measure JavaScript execution, not raw silicon. The same laptop can score meaningfully differently in Chrome, Firefox and Safari because their engines optimise these loops differently.
  • Compare like with like: same browser, same power profile, same battery state. A laptop on battery saver can lose half its score.
  • Parallel efficiency well under 60 per cent on a machine with many cores usually means those cores are hyperthreads sharing execution units, not full cores.
  • A score that falls steadily over repeated runs is thermal throttling. Let the machine cool and retest to confirm.
  • The array sort leans on memory bandwidth as much as the CPU, so a machine with slow or single-channel RAM will lag there while doing fine on the sieve.
  • hardwareConcurrency is a browser-reported number; some browsers cap it for privacy, so a 16-thread machine may spawn fewer workers than you expect.
  • Do not compare these scores with desktop benchmarks such as Cinebench or Geekbench. Different workloads, different units, no conversion.
  • The tab will freeze during the single-thread tests. That is expected: those loops run on the main thread by design.
  • Prime sieve to 2,000,000 on a typed array
  • 512 x 512 Float64 matrix multiplication
  • String concatenation plus JSON encode and decode churn
  • Two-million-element Float64 sort
  • Web Worker scaling test with parallel efficiency
  • SHA-256 throughput in MB/s via Web Crypto
  • Four presets and a per-test score chart
  • Run history for comparison within a session
  • Comparing two laptops quickly without installing benchmark software on either.
  • Checking how much performance a machine loses on battery saver.
  • Seeing whether extra cores actually help, by reading the parallel efficiency figure.
  • Testing whether a browser update changed JavaScript performance on the same hardware.
  • Estimating how a low-end device will cope with a compute-heavy web application.
  • Spotting thermal throttling by running the same preset three times in a row.
It measures how fast your CPU runs these specific JavaScript workloads inside this specific browser. The JIT compiler, the garbage collector and the engine's typed-array optimisations all sit between the code and the silicon, which is why the same machine scores differently in different browsers. That makes it a good relative test — two machines in the same browser, or one machine before and after a change — and a poor absolute one. For a hardware figure, use a native benchmark.
Several reasons, and the efficiency percentage is there to expose them. Logical cores from simultaneous multithreading share execution resources, so two threads on one physical core rarely give twice the throughput. Spawning workers and passing messages costs time that matters on a short run. Background tabs and system processes take cores away. And sustained all-core load on a laptop triggers thermal and power limits within seconds. Efficiency near 100 per cent means clean scaling; 50 to 70 per cent is normal on a hyperthreaded consumer chip.
Each test computes a fixed weight divided by its elapsed time in milliseconds, so the scores are relative rather than tied to any physical unit. A prime sieve that takes half as long scores twice as high. The weights differ per test so that no single workload dominates the total. Because the scale is arbitrary, the only meaningful use is comparison: between machines in the same browser, between browsers on one machine, or between runs before and after a change.
The prime sieve, matrix multiply, string and sort tests deliberately run on the main thread, because that is the thread whose performance most web applications actually depend on. While a tight loop is running, the browser cannot process input or repaint, so the tab appears frozen for a second or two per test. Only the multi-thread test moves work into Web Workers. The freeze is the measurement, not a bug, and the page returns to normal as soon as each test completes.
No. crypto.subtle.digest is implemented in native code and on most modern processors uses dedicated SHA instructions, so the MB/s figure reflects hardware crypto acceleration rather than JavaScript execution. That is why a modest phone can post a surprisingly strong crypto number alongside weak scores elsewhere. Read it as a separate capability: it predicts how fast client-side hashing and encryption will be, which is not the same question as how fast your CPU runs application code.
No. Those benchmarks run native code compiled for your processor and report scores on their own calibrated scales, often normalised against a reference machine. This test runs JavaScript through a browser engine and reports an arbitrary relative score. There is no conversion factor between the two, and attempting one would be misleading. Use this page to compare browsers, machines or settings against each other, and use a native benchmark when you need a number that others can compare against.

Related tools

View all

Part of Hardware testers that run in your browser

Related categories2

Updated

We use anonymous analytics to improve ToolChamp. No personal data is stored or sold. Privacy Policy