Storage. What the browser's file path delivers.
A 64 MiB file written, flushed, read back and read 2,000 times at random inside the browser's private file store, timed in a worker around each call alone, as passes for about half a minute so each figure is a median and not a moment. It measures the browser's storage path, not the drive directly.
How the sustained write finds a drive's cache cliff
Illustrative figures, not a measurement. The test reports your own.
File
64 MiB, deleted after
Sequential
16 chunks of 4 MiB
Random
2,000 reads of 4 KiB
Passes
At least 3, for at least 30 s
Second mode
Sustained write: one file, written for up to two minutes, to show where a drive’s write cache runs out.
It writes gigabytes, not megabytes, to the system drive, and tells you the size before it starts. The file is deleted at the end.
One file, four steps, over and over, then gone.
A web page cannot open your drive. What it can do is write a file into a store the browser keeps for this site, and time how fast that path is. That is what an app in the browser gets, and it is a real figure, but it is not the drive's rated speed and the page does not pretend it is. The four steps run as passes on the one file until at least 30 seconds have passed and at least 3 passes are complete, so no figure is a single moment.
- A synchronous handle in a worker
- The Origin Private File System gives a worker a synchronous access handle: a real write and a real read that return when they are done. The page drives the worker one step at a time, and each step is timed inside the worker around the call alone, so message hops are not in any figure.
- Write, then flush
- 16 chunks of 4 MiB, filled with a fixed pseudo-random pattern so a store that shortcuts empty pages cannot make the write look free, then one flush. The flush is inside the write figure, because until it returns the bytes may still be in a buffer, and its own time is shown beside it.
- Read back, then read at random
- The same 16 chunks read in order, then 2,000 reads of 4 KiB at offsets from a fixed-seed generator, so every run reads the same places. A read this soon after the write is likely served from a cache, and the result says so.
- Sustained write, the second mode
- Chosen on the page before the run. One file is written in 32 MiB chunks for up to 2 minutes or until a cap, with a flush every 256 MiB; the cap is the lesser of 8 GiB and 80% of the free space the browser reports for this site, stated before it starts, and nothing beyond that is requested. Every 8th chunk is then read back and checked against the seeded pattern it was written with, and the file is deleted.
- Again, then deleted
- The write, the flush, the read back and the random reads are one pass. Passes repeat on the same open file until at least 30 seconds of active time have passed and at least 3 are complete; on a fast path that is many passes, on a slow one it is three. Then the file is removed, and again at the start of the next run in case a run was interrupted. Nothing is requested from the browser's quota; if the browser refuses the space, the result says so and does not retry.
Three figures, each a median, with its spread.
No score. Each figure is the median across the passes, with the spread between passes beside it (max minus min as a share of the median), the pass count, and the first pass on its own, since it includes the file's first allocation. Megabytes are decimal, one million bytes, the way drive makers quote them. Sequential write and read speed in MB/s and random 4 KiB reads per second, through the browser's sandboxed storage. Nothing is uploaded, and the file is deleted when the test ends.
Sequential write
64 MiB over the sum of the chunk times plus the flush, in MB/s, worked out for each pass and reported as the median. The spread between passes is shown beside it, and the spread of the median pass's own chunks: a cache filling part way through, or another program on the disk, shows as a large spread.
Sequential read
64 MiB over the sum of the chunk times, in MB/s, the median across passes with the same spreads. Higher than the write on most machines, and often higher than the drive alone, because the bytes just written are still cached.
Random read
2,000 reads of 4 KiB per second (IOPS), the median across passes, and the mean microseconds per read. This is the figure that separates a solid-state drive from a spinning one, and a browser path with a per-call cost from one without.
Passes and flags
How many passes ran and how long they took, and the first pass alone. If the tab was hidden for more than a second, the driver waited between steps and the result says so. A browser without a synchronous handle reports not supported rather than a slow figure.
Illustrative figures, not a measurement. The test reports your own.
Hardware
What it needs. Three tiers, no fine print.
Minimum
Chrome, Edge or Firefox
Any current version; Safari 17 or later. Older Safari and older Firefox have no synchronous handle and report not supported.
Recommended
Some free space, other downloads finished
The file is 64 MiB. A download or a sync client writing at the same time shares the path.
Optimal
Leave the tab in front for the half minute
A hidden tab pauses the passes between steps and the result says so. If the first pass and the median disagree, the difference is the file's first allocation and the cache filling.
Questions
Storage, answered
- Is this my SSD's speed?
- Not directly. The test measures the browser's storage path: the Origin Private File System, which sits on the drive but behind the browser's own layer and the operating system's cache. On a fast drive the path is usually the limit, so the figure says what a web app can get here, not what the drive is rated for. A native tool such as CrystalDiskMark or Blackmagic Disk Speed Test reads the drive itself.
- What is the Origin Private File System?
- A private store the browser keeps for each site, invisible to other sites and to your file manager. This page writes one file there, times it, and deletes it. Nothing is written anywhere you can see, and nothing is uploaded.
- Why is the read so much faster than the write?
- Because the bytes were just written. The browser or the operating system still holds them in memory, so the read back is served from a cache more often than from the drive. The result says so rather than presenting it as the drive's read speed.
- Why does it say not supported?
- The synchronous access handle the test needs exists in Chrome, Edge and Firefox, and in Safari from version 17. An older browser has no path that measures anything honest, so the page reports not supported instead of a made-up figure.
- Why does it take half a minute when one pass takes seconds?
- Because a single pass is a moment, and a moment can land on a cache filling, a sync client waking up or the file's first allocation. The test repeats the same workload as passes for at least 30 seconds and at least 3 passes, reports the median of the passes as each figure, and shows the spread between passes so you can see how steady the path was.
- What does the sustained write show?
- Where a drive's write cache runs out. Most TLC and QLC solid-state drives write first into a fast cache, a part of the flash used one bit per cell (SLC), and once it is full they write at the much slower native rate. The curve of rate over bytes written shows the fall; the cache size estimate is the bytes written before the rate dropped below 50% of its first-GiB median and stayed there for at least 3 chunks, both our lines. A curve that never falls says no cache cliff within the size written, which is common and fine.
- Why can the first sustained figures be flattering?
- The browser's storage path includes the operating system's cache, so the first chunks can land in memory before they reach the drive. The flushes every 256 MiB push them on, and their time is shared across the chunks they flushed, but the early figures can still read higher than the drive.
- Can it find a fake-capacity USB stick or SD card?
- Not this test. It writes only to the browser's private store, which is on the system drive. The USB drive speed test on this site can, in Chrome or Edge: it writes to a folder you pick on the stick, reads every byte back, and with its full check fills the free space. Native tools do the same: H2testw on Windows, F3 on Linux and macOS, or GRC ValiDrive, all free. The read-back check here reports any chunk that does not match, which on the system drive would point to a fault.
- Is this part of the main SystemCheck run?
- No. It runs on this page only, on its own, and it does not change the score or the report.