About

Hardware failures rarely manifest at idle. They emerge under sustained thermal and electrical load - the exact conditions a burn-in test replicates. This tool applies continuous stress to your CPU (via recursive computation in Web Workers), GPU (via high-throughput Canvas rendering), and RAM (via pattern-write verification on ArrayBuffers) to surface intermittent faults before they cause data loss. The stability metric is the coefficient of variation C_v = σμ of throughput over time: values above 0.15 indicate thermal throttling or failing components. All computation runs client-side - no data leaves your machine.

Limitation: browser sandboxing prevents direct hardware access. This tool approximates system stress through JavaScript execution paths. Results correlate with but do not replace dedicated tools like Prime95 or MemTest86. Short tests under 5 minutes may miss intermittent faults that only appear after thermal saturation. For production server validation, run a minimum of 30 minutes per subsystem.

Formulas

The core stability metric computed for each test module over its sampling window:

C_v = σμ = √1N N∑i=1 (x_i − x)²x

Where x_i is the throughput sample at interval i, x is the mean throughput across N samples, and σ is the standard deviation. A C_v < 0.10 indicates stable hardware. Values between 0.10 and 0.15 suggest thermal throttling. Values > 0.15 indicate potential hardware instability.

Memory verification uses XOR checksum across each allocated block:

V = n−1∑i=0 W_i ⊕ E_i

Where W_i is the written byte at offset i, E_i is the expected pattern byte, and ⊕ is XOR. If V ≠ 0, a bit error has been detected at that memory region.

GPU throughput is measured as sustained frames per second with a rolling average over 60 frames:

FPS_avg = 1000160 60∑i=1 Δt_i

Where Δt_i is the frame duration in milliseconds.

Reference Data

Test Module	Method	Metric	Stable Threshold	Failure Indicator
CPU Integer	Prime Sieve (Eratosthenes)	Primes/sec	C_v < 0.10	Sudden throughput drop > 30%
CPU Float	Matrix Multiply (128×128)	MFLOPS	C_v < 0.12	NaN or precision drift
CPU Recursive	Fibonacci(38)	Calls/sec	C_v < 0.10	Stack overflow or hang
Memory Pattern	Walking 1s on ArrayBuffer	MB/s verified	0 errors	Any bit mismatch
Memory Checkerboard	0xAA/0x55 alternation	MB/s verified	0 errors	Any bit mismatch
Memory Sequential	All-0xFF then All-0x00	MB/s verified	0 errors	Any bit mismatch
GPU Fill Rate	Canvas rect flood (10000 rects/frame)	FPS sustained	FPS ≥ 30	FPS < 15 sustained
GPU Particles	5000 animated sprites	FPS sustained	FPS ≥ 24	Frame drops > 50%
GPU Compositing	Layered alpha blending	FPS sustained	FPS ≥ 20	Visual artifacts
Audio Latency	Oscillator bank (32 voices)	Latency ms	< 50ms	Glitches or silence
Combined Load	All modules simultaneous	Aggregate score	All pass individually	Any single module fail
Thermal Ramp	Progressive load increase	Throughput curve	Linear or plateau	Negative slope (throttle)
Endurance	Fixed load over time	Time to first error	> 30min	< 5min

Frequently Asked Questions

For consumer hardware, a minimum of 30 minutes per subsystem (CPU, GPU, memory) provides reasonable confidence. Intermittent faults caused by thermal expansion often appear after 15-20 minutes as components reach steady-state temperature. Server-grade validation typically requires 4-24 hours. This browser-based tool is limited by JavaScript execution constraints, so results exceeding 30 minutes of stable operation with C_v < 0.10 across all modules indicate good baseline stability.

This is thermal throttling. Modern CPUs reduce clock speed when junction temperature exceeds a threshold (typically 85-100°C depending on manufacturer). The throughput graph will show a negative slope after the initial plateau. A gradual 5-10% reduction is normal under sustained load. A sudden drop exceeding 30% may indicate inadequate cooling - check thermal paste application, heatsink mounting pressure, and case airflow.

Not at the same level. MemTest86 operates below the OS layer with direct hardware access and tests all physical addresses. This tool allocates memory through the JavaScript engine, which adds a virtualization layer. However, the pattern-write-verify approach (walking 1s, checkerboard, sequential fill) can still detect gross memory corruption, stuck bits, and address line faults within the browser's allocated heap. Zero errors here is necessary but not sufficient - a clean result should be confirmed with bare-metal testing for production systems.

Canvas 2D operations still exercise the GPU's 2D acceleration pipeline, compositor, and VRAM bandwidth. Rendering thousands of semi-transparent, rotated rectangles per frame stresses fill rate, alpha blending units, and the CPU-GPU data bus. While it does not test 3D shader pipelines or CUDA/OpenCL compute units, sustained Canvas rendering at high load will elevate GPU temperature and expose thermal or power delivery issues. FPS stability (not peak FPS) is the diagnostic metric.

Combined load testing stresses the power delivery unit (PSU/battery), memory controller, and system bus simultaneously - conditions that sequential tests cannot replicate. A system that passes each module individually but fails under combined load likely has a power delivery bottleneck. However, combined results are harder to diagnose since a failure could originate from any subsystem. Best practice: run sequential tests first to establish baselines, then run combined to test system-level stability.