About

A CPU stress test pushes each logical core to 100% utilization by running computationally dense loops - matrix multiplications, trigonometric chains, and prime sieves - simultaneously across N threads. The purpose is to detect thermal throttling, validate cooling solutions, and identify unstable overclocks before they cause data corruption or system crashes. This tool spawns real Web Workers that execute actual floating-point and integer arithmetic; it does not simulate load. Each worker reports operations per second, which are graphed in real time. The aggregate score is normalized per-thread as S = ops10⁶, giving a comparable metric across machines.

Limitations: browser-based tests cannot access hardware temperature sensors or ring-0 instruction sets (AVX-512, SSE4). Measured throughput reflects JavaScript engine efficiency (V8, SpiderMonkey) as much as raw silicon performance. Results are indicative, not absolute. For production-grade burn-in, supplement with native tools. Still, this test will saturate your CPU and expose throttling within 30 - 60 seconds on inadequately cooled systems.

Formulas

Each worker thread executes a tight computation loop and reports the total number of atomic operations completed per reporting interval. The per-thread score is calculated as:

S_thread = ops10⁶ ⋅ t

Where S_thread is the thread score in Mops/s (mega-operations per second), ops is the raw operation count, and t is the elapsed time in seconds. The aggregate multi-thread score sums all thread scores:

S_total = N∑i=1 S_i

Where N is the number of active threads (capped at navigator.hardwareConcurrency). Throttle detection compares the current 5-second moving average against the peak recorded average. A drop exceeding 15% triggers a throttle warning:

throttle = S_peak − S_currentS_peak × 100

For the matrix multiplication workload, each iteration multiplies two 64×64 matrices, yielding n³ = 262,144 multiply-accumulate operations. The prime sieve uses the Sieve of Eratosthenes up to 100,000, crossing off composites via modular arithmetic. The trigonometric chain computes chained sin(cos(atan2(x, y))) sequences to stress the FPU pipeline.

Reference Data

Benchmark Workload	Operation Type	Complexity per Iteration	Primary Bottleneck	Typical Score Range
Matrix Multiply (64×64)	FP64 Multiply-Add	O(n³) ≈ 262,144 FLOPs	ALU / L1 Cache	50 - 400 Mops/s
Trigonometric Chain	sin, cos, atan2	1,000 transcendental calls	FPU Pipeline	10 - 120 Mops/s
Prime Sieve (Eratosthenes)	Integer, Branch	Sieve to 100,000	Branch Predictor / Memory	20 - 200 Mops/s
Fibonacci (BigInt)	Arbitrary Precision	5,000th term	Memory Allocation	5 - 80 Mops/s
Mixed (All Combined)	All of the above	Weighted round-robin	Overall CPU	30 - 250 Mops/s
Reference Single-Thread Scores (Mixed Workload)
Intel i9-13900K	Mixed	-	-	≈ 220 Mops/s
AMD Ryzen 9 7950X	Mixed	-	-	≈ 210 Mops/s
Apple M2 Pro	Mixed	-	-	≈ 190 Mops/s
Intel i7-12700K	Mixed	-	-	≈ 170 Mops/s
AMD Ryzen 5 5600X	Mixed	-	-	≈ 130 Mops/s
Intel i5-10400	Mixed	-	-	≈ 90 Mops/s
Apple M1	Mixed	-	-	≈ 150 Mops/s
Intel i3-8100	Mixed	-	-	≈ 55 Mops/s
AMD Ryzen 3 3200G	Mixed	-	-	≈ 60 Mops/s
Snapdragon 8 Gen 2 (Mobile)	Mixed	-	-	≈ 70 Mops/s

Frequently Asked Questions

Score fluctuation indicates thermal throttling or OS-level frequency scaling. Modern CPUs reduce clock speed when junction temperature exceeds a threshold (typically 95 - 105°C for Intel, 90 - 95°C for AMD). The test detects drops exceeding 15% from peak and flags them. If you see consistent decline after 30 seconds, your cooling solution is insufficient for sustained load.

Native tools access AVX-512, SSE4, and ring-0 instructions that generate more heat per cycle than JavaScript can. This browser test stresses the CPU through JavaScript engine hot paths (JIT-compiled floating-point and integer arithmetic). It will not reach the thermal ceiling as fast as Prime95 Small FFTs, but it reliably detects throttling and provides a relative performance metric. Treat it as a quick validation tool, not a replacement for 24-hour burn-in testing.

Yes. Each open tab consumes memory and may trigger garbage collection pauses in the JavaScript engine. Background tabs may also be throttled by the browser (Chrome reduces timer resolution to 1Hz for background tabs). Close all other tabs and applications for the most accurate results. The test tab must remain in the foreground.

Perfect linear scaling (S_total = N × S_single) is impossible due to shared resources: L3 cache contention, memory bandwidth saturation, and power budget limits (PL1/PL2 constraints). Hyperthreaded (SMT) cores share execution units, yielding roughly 20 - 30% additional throughput per virtual core rather than 100%. Efficiency cores (Intel P/E architecture) also score lower than performance cores.

Use Mixed for general stability. If you are tuning memory timings, Prime Sieve stresses the memory subsystem more. For FPU-heavy overclocks, Trigonometric Chain is most sensitive to floating-point unit instability. Matrix Multiply tests sustained ALU throughput. Run for at least 5 minutes; instability often manifests after thermal saturation.

No. Modern CPUs have hardware thermal protection (PROCHOT) that throttles or shuts down before damage occurs. However, if your cooling system is misconfigured (e.g., no thermal paste, dead fan), sustained 100% load will trigger thermal shutdown. The test itself is safe; it reveals existing hardware problems rather than creating them.