METHODOLOGY

How the Benchmark Works

Complete transparency on what we measure, how scores are calculated, and the honest limitations of browser-based benchmarking.

Our Multi-Tier Testing Philosophy

Most online benchmarks just run a simple calculation. ArcadiumGG uses a Multi-Phase Synthetic Workload. This approach mimics how modern games interact with your hardware: quick bursts of high-intensity logic followed by massive data transfers between the CPU and GPU memory.

CPU Test — 5 Phases (~25–40s)

PhaseWorkloadWhat it measures
1 · Monte Carlo 80M random samples, LCG PRNG FP throughput, branch prediction
2 · Mandelbrot 800×800 px, max 512 iterations Complex FP math, tight inner loop
3 · Matrix Multiply 256×256 tiled (TILE=32), Float64 Cache behaviour, arithmetic intensity
4 · SHA-256 Chain 50M rounds, 8 constants, bitwise ops Integer pipeline, register pressure
5 · Prime Sieve Sieve of Eratosthenes to 10M Sequential memory access, branching

Score formula: (28,000ms_reference / actual_total_ms) × 10,000
28,000ms = calibrated time for a Ryzen 5 5600 (2021 mid-range).

Why these tests?

We chose these 5 specific algorithms because they stress different parts of the CPU architecture. Monte Carlo and Mandelbrot test floating-point precision (essential for game physics). SHA-256 tests the integer pipeline (NPC logic), and Prime Sieve tests how your CPU handles branching paths in code.

GPU Test — Compute Shader (~15–30s)

Path 1 — WebGPU (preferred)

  • Buffer: 2 × Float32 arrays of 2.1M elements each (256MB total)
  • Kernel: 256-thread workgroups, 8,192 dispatch groups = 2.1M threads/pass
  • Inner loop: 512 iterations of sqrt(v²) + FMA per thread
  • Passes: 40 — batched in groups of 8 with GPU sync between batches
  • Total: ~85 billion shader operations

Path 2 — WebGL2 fallback

  • Canvas: 2048×2048 = 4.2M pixels per frame
  • Fragment shader: 512 iterations of branch-free Mandelbrot per pixel
  • Frames: 60 with forced gl.finish() sync

WebGPU score: (8ms_ref / ms_per_pass) × 10,000
WebGL2 score: (60ms_ref / avg_frame_ms) × 10,000

Memory Test — 5 Phases (~10–20s)

PhaseWorkloadWhat it measures
1 · Seq. Write Fill 512MB Float32Array linearly Write bandwidth (GB/s)
2 · Seq. Read Sum 512MB Float32Array linearly Read bandwidth (GB/s)
3 · Copy BW TypedArray.set() 256MB src→dst Effective copy bandwidth
4 · Random Access 2M LCG-indexed reads, full range Cache-miss latency (ns)
5 · Stride Stress Strides 16/64/256/1024 over 32M elements TLB pressure, cache line efficiency

Score: (avg_bandwidth_GBs / 20) × 10,000
20 GB/s reference ≈ DDR4-4000 dual-channel peak.

Overall Score

Weighted combination: GPU × 40% + CPU × 40% + Memory × 20%

GPU and CPU are equally weighted. Memory has lower weight because browser JS cannot fully stress RAM subsystems the way native code can.

Score Normalization

A score of 10,000 is our "baseline 2026 standard." If your score is 20,000, your system is theoretically twice as capable as our reference mid-range build. This allows you to compare a 2018 rig against a 2026 flagship using the same scale.

RTX 4090 + i9-14900K~42,000
RTX 4070 + Ryzen 7 7800X3D~28,000
RTX 3060 + Ryzen 5 5600~12,000
GTX 1060 + i5-8400~6,000
Integrated GPU (iGPU)<2,000

Confidence Score (0–100)

Penalties applied to raw confidence of 100:

  • −20 if device is mobile (thermal throttle risk)
  • −40 if GPU path = Canvas 2D (no shader workload)
  • −10 if GPU path = WebGL2 (less pipeline control)
  • −20 if total CPU time < 5,000ms (suspicious — possible throttle or background boost)

A confidence below 60 means the result should be treated as approximate.

What This Benchmark Does NOT Measure

  • Real game FPS — browsers cannot access DX12/Vulkan directly
  • Multi-core parallelism — JS runs single-threaded (WebWorker support is planned)
  • Storage / NVMe bandwidth
  • Network latency
  • True thermal throttling (though repeated identical results would indicate stability)
  • Ray-tracing hardware capability
Run Benchmark → View Rankings