Memory Speed Test

Memory Speed Test - Test Your RAM Performance

A comprehensive online memory speed testing tool that measures RAM performance through various operations. Run tests for array operations, object allocation, string manipulation, typed arrays, and memory allocation to evaluate your system's memory speed and efficiency.

How does memory speed testing work?

Memory speed testing measures RAM performance by executing various operations:

1. Array Operations: Tests read/write speed with standard arrays (10,000 elements)
2. Object Allocation: Measures object creation and modification speed (1,000 objects)
3. String Manipulation: Evaluates string concatenation, split and replace performance
4. Typed Arrays: Tests binary data handling with Int32, Float64 and Uint8 buffers
5. Memory Allocation: Measures large memory allocation efficiency

Each test runs for a set duration and calculates operations per second. Higher ops/sec values indicate better memory performance. The tool uses performance.now() for sub-millisecond timing.

What factors affect memory speed?

Several factors influence memory test results:

- RAM Amount: More RAM allows larger working sets without swapping
- RAM Speed: Higher MHz (3200, 4800, 6400 MT/s) = faster data access
- RAM Type: DDR5 > DDR4 > DDR3 (bandwidth doubles each generation)
- CPU Cache: L1/L2/L3 cache sizes affect memory access patterns
- Memory Channels: Dual/quad channel doubles or quadruples bandwidth
- Browser Limitations: V8/SpiderMonkey heap caps (typically 2-4GB)
- Background Processes: Other apps consuming RAM trigger swapping
- Operating System: Memory management efficiency (Linux > Windows for large allocations)

For accurate results, close background applications and ensure ample free RAM.

What is a good memory speed score?

Understanding your memory speed results:

- Higher Operations/Second = Better Performance
- Lower Time = Faster Completion

Typical scores by system tier:
- High-End Desktop (32GB+ DDR5-6400): 50-100+ ops/s
- Mid-Range Desktop (16GB DDR4-3200): 30-50 ops/s
- Budget Desktop (8GB DDR4-2400): 15-30 ops/s
- Modern Laptops: 10-40 ops/s (varies widely)
- Mobile/Tablets: 5-15 ops/s

Note: Scores vary significantly by browser and JavaScript engine optimization (V8 vs SpiderMonkey vs JavaScriptCore).

Why test memory in browser?

Browser-based memory tests offer advantages:

- No Installation: Test immediately without downloads
- Cross-Platform: Works on any OS with a browser
- Safe: Runs in sandbox, can't damage system
- Quick Diagnostics: Identify memory bottlenecks fast
- Web Performance: See how web apps will perform on this device

While not as comprehensive as native tools like MemTest86 or AIDA64, browser tests provide valuable insights into JavaScript memory performance, which matters for web applications, Node.js, and browser-based workloads.

What is the JavaScript heap and why does it limit memory tests?

The JavaScript heap is the dedicated memory region where the JS engine (V8, SpiderMonkey, JavaScriptCore) allocates objects, arrays and strings. Browsers cap the heap to prevent runaway pages: Chrome desktop ~4 GB, Firefox ~2 GB, mobile Chrome ~256-512 MB, Safari iOS ~384 MB. When a test asks for more memory than the cap, the engine throws RangeError or triggers garbage collection that distorts timings. window.performance.memory (Chromium only) reports jsHeapSizeLimit, totalJSHeapSize and usedJSHeapSize so you can see how close you are to the ceiling.

Why are typed arrays faster than regular arrays?

Regular JavaScript arrays store boxed values: every element holds a pointer plus a 64-bit floating-point tag, even for integers. Typed arrays (Int32Array, Float64Array, Uint8Array) store raw binary data in a contiguous ArrayBuffer with no boxing. Reading element i means reading bytes [i*4 .. i*4+3] directly, identical to C. This skips garbage collection, avoids hidden-class transitions, and lets the JIT emit SIMD instructions. Result: typed arrays are typically 2-5x faster for numerical workloads and use 4-8x less memory.

What does the heap-used number actually mean?

window.performance.memory.usedJSHeapSize reports how many bytes the V8 garbage collector currently considers reachable through the page's root objects. It excludes detached DOM nodes pending sweep, native buffers (ArrayBuffer backing stores live outside the JS heap), and inline cache data. Numbers jump when GC runs (every 50-200ms under load) and the value is rounded to the nearest 100 KB for privacy (mitigates timing attacks like Spectre). Firefox and Safari do not expose this API for the same reason.

Why does the test slow down on subsequent runs?

Three effects compound:

1. Garbage collection backlog: each run leaves objects for GC; the second run pays for cleanup of the first.
2. Heap fragmentation: repeated allocate/free cycles create gaps the allocator must scan past, raising allocation latency.
3. Thermal throttling: sustained CPU+RAM activity for 30+ seconds raises silicon temperature past TJMax (~100°C), at which point the CPU/memory controller down-clocks 10-30 % to avoid damage.

To get a stable baseline, click Reset Results, wait 10 seconds for GC and cooling, then re-run.

Which browsers expose performance.memory and navigator.deviceMemory?

Only Chromium-based browsers (Chrome, Edge, Opera, Brave) expose them, and both are non-standard and deprecated:

- performance.memory (jsHeapSizeLimit / totalJSHeapSize / usedJSHeapSize): Chromium only. Firefox and Safari deliberately do not implement it to block Spectre-style timing attacks. Values are quantized (rounded to ~100 KB).
- navigator.deviceMemory: Chromium only and privacy-quantized to one of {0.25, 0.5, 1, 2, 4, 8} GB. A 16 GB or 32 GB machine both report "8 GB", so this is an approximate browser hint, NOT your installed RAM.

On Firefox and Safari the Memory Information card shows "Not supported" for these fields — that is expected, not a bug. The benchmark (array, object, string, typed-array and allocation ops/s) uses only performance.now() and runs identically on every browser.

Is this safe and private? Does it need permissions?

Yes. The benchmark runs 100% client-side in your browser tab using ordinary JavaScript and performance.now(). Nothing is uploaded, no account, no permission prompt and no secure-context (HTTPS) requirement — it works offline. The optional JSON/CSV export is generated locally in your browser and saved straight to your device; it is never sent to any server.

How do I read the results for QA pass/fail?

Use the multi-run statistics, not a single number:

1. Set Iterations to 5 or 10 so each test produces a sample set with avg ± stddev, median, min and max.
2. Judge stability with the CV (coefficient of variation = stddev/avg) badge: green under 5 % = repeatable; yellow 5-15 % = borderline (background load or mild throttling); red over 15 % = unstable, likely thermal throttling or GC pressure — re-test on a cool, idle machine before certifying.
3. Compare the median (robust to outliers) rather than the average for pass/fail against a known-good baseline.
4. The Composite Index is a unitless geometric mean of the five medians — use it to rank devices; use the per-test medians to localize a weakness.
5. Export JSON/CSV to attach the full session (timestamp, user agent, samples, stats, index) to a ticket or compare against a baseline file.

Key Features

• 5 comprehensive memory speed tests
• Real-time operations per second measurement
• Array operations performance testing
• Object allocation and manipulation benchmarks
• String manipulation speed tests
• Typed array performance evaluation
• Large memory allocation testing
• Memory information display (heap, limit)
• Multi-run sampling (1/3/5/10 iterations)
• Per-test min/max/average/median and standard deviation
• Run-to-run variance (CV) stability badge
• Geometric-mean composite index (not a misleading arithmetic mean)
• JSON and CSV export of the full session report
• Individual test timing and scoring
• Visual progress indicators
• Stop test anytime
• Reset and re-run tests
• 100% client-side - no data uploaded
• Works offline
• Mobile and desktop support
• Dark mode compatible