CrystalDiskMark 9.0.3 is still the newest build of the free SSD benchmark on the developer’s site as of October 28, 2026. Its sibling tool CrystalDiskInfo moved to 9.9.3 on October 11, 2026, and the same day the developer announced that CrystalDiskInfo passed 100 million cumulative downloads after 18 years. That pairing is the one this guide uses: CrystalDiskMark to measure speed, CrystalDiskInfo to check health.
You will run a clean CrystalDiskMark SSD speed test in 13 steps and about 30 minutes. The routine works whether you just installed a new NVMe drive, bought a used one, or want to find out why a laptop feels slower than it did in spring. You will learn which settings matter, how to read every row of the results grid, and how to tell a real fault from a test you set up badly.
The last step turns the whole routine into a small PowerShell project. It records your hardware and power state, parses the text file CrystalDiskMark saves, appends the numbers to a CSV, and flags any row that drops against your own baseline. One screenshot proves little, but a log of five runs over six months tells you something real.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Why an SSD Speed Test Matters When Drive Prices Are High
SSD prices have been climbing, and that raises the cost of a bad purchase. A market report updated October 19, 2026 listed the Kingston NV3 2TB at $278.99, down from a reported earlier peak of $329.99, according to PC Guide’s deal coverage. That is a retail price movement, not a product change, but it shows the point: when a 2TB drive costs several hundred dollars, you want proof it performs the way the box says.
The number printed on a retail box is almost always a best-case sequential read. It comes from a specific capacity, a specific PCIe slot, a fresh drive, and a cool room. Your machine differs in at least three of those. A benchmark run on your own system shows what you actually got, which is the only figure that should drive a return, a warranty claim, or an upgrade decision.
Interface matters even more than the drive. A fast NVMe SSD in a slot that runs at reduced width will post numbers well under its rating. A SATA drive will never reach NVMe territory no matter how clean the test is, a gap we covered in our NVMe vs SATA SSD comparison. CrystalDiskMark exposes both situations in a few minutes, provided you set it up so the results mean something.
There is also a second, quieter reason to test: baselines. Drives slow down as they fill, as firmware changes, and as thermal paste or heatsink pads age. If you saved a clean result the week you bought the drive, a drop later is evidence. Without it, you are guessing from memory.
What CrystalDiskMark Measures and What It Skips
CrystalDiskMark applies a defined read and write workload to a chosen volume and reports throughput, IOPS, and average latency. It answers one question: how fast does this connection move data under this workload? It does not tell you whether the drive is healthy, whether the advertised capacity is real, or whether your files copied correctly. Mixing those questions up is the most common reason people draw the wrong conclusion from a benchmark screenshot.
Crystal Dew World ships two separate tools for a reason. CrystalDiskInfo reads S.M.A.R.T. attributes, temperature, and drive identity. CrystalDiskMark generates load and times it. Use them in that order, because a drive that already reports a warning should be backed up and investigated, not hammered with write tests. Our SSD health check tutorial covers the health side in more depth.
| Question you have | Right tool | Why a speed test cannot answer it |
|---|---|---|
| How fast is this drive and connection? | CrystalDiskMark | Nothing, this is its job |
| Is the drive wearing out or reporting errors? | CrystalDiskInfo and vendor diagnostics | A high score cannot rule out failure |
| Is the full advertised capacity real? | Full-capacity write and read-back check | A 1 GiB test file touches a tiny slice of the drive |
| Did my file copy arrive intact? | Hash comparison of source and copy | Fast transfer says nothing about file contents |
| Why does Windows feel slow? | Task Manager, startup audit, then benchmarks | CPU, RAM, and software behavior all affect feel |
One more fact shapes everything below. CrystalDiskMark writes test data to the drive, so it is not a read-only check. The developer’s units are decimal for throughput, where MB/s means 1,000,000 bytes per second, while test sizes use binary units such as GiB. Keep that mismatch in mind when you compare the grid against a manufacturer spec sheet.
Prerequisites and Versions You Need Before Starting
You need a Windows PC, about 30 minutes, and a drive whose contents you have backed up. Nothing here requires a paid license. The table lists what to have ready and which versions the facts in this guide were checked against on October 28, 2026.
| Item | Version or requirement | Notes |
|---|---|---|
| CrystalDiskMark | 9.0.3 | Newest build listed on the official site, no later release shown |
| CrystalDiskInfo | 9.9.3 (released October 11, 2026) | Used for the health check in Step 4 |
| Operating system | Windows 10 or Windows 11 | The developer lists NVMe support as requiring Windows 10 or Server 2016 or later |
| PowerShell | Windows PowerShell 5.1 or newer | Ships with Windows 10 and 11, needed for the Step 13 project |
| Permissions | Standard user for testing, Administrator for some SMART counters | Network shares disappear from the drive list when CrystalDiskMark runs elevated |
| Free space | More than the test file size plus a healthy margin | The default test file is 1 GiB |
| Backup | Verified copy of anything on the target drive | The test writes data, so protect your files first |
| Time | About 30 minutes for the first run and log | Repeat runs take a few minutes each |
The official download page lists Standard, Shizuku, and Aoi editions, and reportedly also sells the same editions through the Microsoft Store at $9.99 each. The editions differ in artwork, not in the benchmark engine, so the free Standard edition is the right pick for this tutorial. Pin your notes to the exact version string you see in the title bar after launch, because results from different major versions are not directly comparable.
Finally, prepare the machine. Close game launchers, cloud sync clients, browsers with many tabs, and anything that touches the disk. Plug a laptop into AC power and set the same power mode you will use for every future test. These choices cost nothing, and they remove the variables that make two runs of the same drive disagree by double-digit percentages.
Steps 1-3: Download the Official Build, Protect Your Data, and Identify the Target Drive
Step 1: Download CrystalDiskMark from the developer. Go to the Crystal Dew World site at crystalmark.info, open the CrystalDiskMark page, and follow its download link. Search results regularly surface lookalike domains and repackaged installers, so type the address yourself instead of clicking an ad. Pick the Standard edition, then choose the ZIP if you want a portable copy or the installer if you prefer a Start menu entry. After launching, read the version in the title bar and write it down. It should read 9.0.3.
Step 2: Back up and quiet the system. Copy anything irreplaceable off the target drive, or confirm your existing backup restores. If you plan to move a system disk to a new SSD, run this benchmark on the new drive first and then follow our guide to clone a hard drive to an SSD, so you know the clone destination is healthy before you trust it. Then pause updates, quit sync tools, and let any running installers finish. Do not disable antivirus to chase a bigger number. A test that only works with protection off is not a test of your real system.
Step 3: Map the drive letter to the physical SSD. CrystalDiskMark tests a volume, and a drive letter is not a hardware identity. One SSD can hold both C: and D:, while two identical-looking drives can swap letters after a reboot. These read-only PowerShell queries tie a letter to a model. Replace D with your target letter. They query information and do not initialize, format, or benchmark anything.
Get-Volume -DriveLetter D | Select-Object DriveLetter, FileSystemLabel, FileSystem, Size, SizeRemaining
Get-Partition -DriveLetter D | Get-Disk | Select-Object Number, FriendlyName, BusType, Size, OperationalStatus
Get-PhysicalDisk | Select-Object DeviceId, FriendlyName, MediaType, BusType, FirmwareVersionRead the output for three things. The BusType column should say NVMe for an M.2 NVMe drive, SATA for a 2.5-inch or M.2 SATA drive, and USB for anything in an external enclosure. The disk number from the second command should match a DeviceId in the third. And OperationalStatus should read OK. If the BusType surprises you, stop and sort that out first. A drive you believed was NVMe that reports SATA, or an internal drive that reports USB, explains a slow result before you ever click a button.
DeviceId FriendlyName MediaType BusType FirmwareVersion
-------- ------------ --------- ------- ---------------
0 <your system SSD model> SSD NVMe <firmware string>
1 <your second drive> SSD NVMe <firmware string>The block above shows the shape of the output with placeholders, since your model names and firmware strings will differ. Save the model, capacity, and firmware lines. You will paste them into your log in Step 13, and they let a future you confirm that a slow result came from the same drive and the same firmware as the fast one.
Steps 4-5: Check Drive Health and Record the Test Environment
Step 4: Run CrystalDiskInfo 9.9.3 first. Download it from the same developer site, launch it, and select the target drive from the tabs along the top. Three fields matter. The Health Status box should read Good. The temperature should sit at a sensible idle value for your enclosure and cooling. The Transfer Mode line shows the link the drive negotiated with the host, and on NVMe drives it lists the PCIe generation and lane count in use next to the maximum the drive supports. A drive that supports four lanes but runs at fewer is a classic cause of results far below the rating. The version numbers and release date come from the WindowsForum diagnostics walkthrough, which also covers reading drive health before you upgrade hardware.
If CrystalDiskInfo shows Caution or Bad, stop the benchmark plan. Crystal Dew World published guidance on those states on July 18, 2026, and it recommends backing up important data before you investigate the cause. A third-party explainer, the CrystalDiskInfo status guide from Clearquote Data Recovery, walks through what each attribute means. Repeated write benchmarks on a failing drive add stress and tell you nothing useful.
Step 5: Record the environment. A benchmark result without context is a number with no meaning. Write down the drive model, capacity, and firmware, the slot or the full enclosure chain, the CrystalDiskMark version, free space on the volume, the power source and power mode, and the drive temperature before you start. You can capture most of this with PowerShell. Run the window as Administrator, because the reliability counters often need elevation.
Get-PhysicalDisk | Get-StorageReliabilityCounter | Select-Object DeviceId, Temperature, Wear, ReadErrorsTotal, WriteErrorsTotal, PowerOnHours
powercfg /getactivescheme
Get-CimInstance Win32_OperatingSystem | Select-Object Caption, Version, BuildNumberSome drives and bridges do not expose every counter, so blanks are normal on external enclosures. If ReadErrorsTotal or WriteErrorsTotal shows nonzero values on an internal drive, treat that the same way as a Caution status: back up first, benchmark later. When the temperature is already high before the test, wait for the drive to cool or improve airflow. A heat-soaked drive throttles early and gives you a result you cannot reproduce tomorrow.
Steps 6-7: Set the Run Count, Test Size, and Test Data
Step 6: Choose the run count and file size. Open CrystalDiskMark and look at the three drop-downs along the top. The first sets the number of runs per test, from 1 to 9, with a default of 5. The second sets the test file size, from 16 MiB to 64 GiB, with a default of 1 GiB. The third selects the target drive letter. A fourth control switches the unit between MB/s, GB/s, IOPS, and average latency in microseconds. For a first baseline, keep the defaults on an internal SSD. For a slow USB flash drive, drop to 64 MiB or 256 MiB so the progress bar does not crawl for ages.
Step 7: Choose the test data type. Under Settings, the Test Data option selects the payload pattern. Random is the default and writes incompressible pseudo-random data. All 0x00 (0 Fill) writes streams of zeroes. This is not a sector scan or a health check, a misunderstanding that appears in some guides. Some controllers compress data on the fly, so a zero-filled test can report inflated write speeds on those drives. Stay on Random for any comparison against a spec sheet or another reviewer’s chart, and use 0 Fill only when you are deliberately studying compression behavior.
| Setting | Default | Change it when | Risk of changing |
|---|---|---|---|
| Number of runs | 5 (range 1 to 9) | You want a fast check (use 1) or a steadier average (use 5 or more) | More runs write more data and wear the drive slightly |
| Test file size | 1 GiB (range 16 MiB to 64 GiB) | Slow USB sticks need less, cache studies need more | Results from different sizes are not comparable |
| Target drive | First volume in the list | Always select it deliberately | Testing the wrong volume wastes the whole run |
| Test data | Random | Only for compression experiments | 0 Fill can overstate speed on some controllers |
| Unit | MB/s (1,000,000 bytes per second) | Switch to IOPS or microseconds to study random behavior | Mixing units makes comparisons wrong |
Test size deserves a second look. A larger file does not guarantee that you outrun the drive’s fast write cache, and a small file cannot show sustained speed after that cache fills. The default 1 GiB reflects short, bursty work, which is how most people use a drive. If you want to study sustained behavior, change the size on purpose, label the result with the new size, and never compare it to a 1 GiB run. For a first baseline, the editorial guidance in the SSD Hardware Database guide is a sensible starting point: begin with the default configuration, run 1 GiB once, and only then repeat under matching conditions.
A final settings note covers network drives. If you launch CrystalDiskMark with Administrator rights, Windows hides mapped network shares from the drive list because elevated sessions do not see the standard user’s mappings. To test a NAS share, close the elevated copy and start CrystalDiskMark as a normal user. Local drives work either way, but Administrator mode is not a speed boost, and it does not make a flaky result more accurate.
Steps 8-9: Pick the Default or NVMe SSD Preset and Run the Benchmark
Step 8: Choose a preset. The Settings menu holds the presets that decide which workload rows appear. According to the developer’s documentation as summarized by WindowsForum, the Default preset runs sequential 1 MiB reads and writes at queue depth 8 and 1 with one thread, plus random 4 KiB at queue depth 32 and 1 with one thread. The NVMe SSD preset swaps in a deeper random test at queue depth 32 with 16 threads, which gives fast PCIe drives enough parallel work to show their ceiling. The Flash Memory preset targets thumb drives and memory cards.
| Preset or profile | What it runs | Best for |
|---|---|---|
| Settings > Default | SEQ1M Q8T1 and Q1T1, RND4K Q32T1 and Q1T1 | SATA SSDs, hard drives, and a common baseline across drive types |
| Settings > NVMe SSD | SEQ1M Q8T1, SEQ128K Q32T1, RND4K Q32T16, and RND4K Q1T1 | PCIe NVMe drives that need deep queues to show full capability |
| Settings > Flash Memory | Lighter workload tuned for removable media | USB sticks and memory cards |
| Profile > Peak Performance | Heavy queue and thread combinations | Maximum throughput checks |
| Profile > Real World Performance | Single-queue depths typical of everyday use | Responsiveness checks |
| Profile > Demo | Quick single-line snapshot | Fast sanity check |
| Profile > Mix variants | Adds a column with simultaneous reads and writes, defaulting to a 70 percent read and 30 percent write split | Mixed workloads such as databases and busy desktops |
A preset changes the workload, not the hardware. The NVMe SSD preset will not make a SATA drive faster, and picking it for a thumb drive will not harm anything, but it produces rows you cannot compare to a flash-oriented chart. The rule is consistency. Use the Default preset for your first record because every drive type supports it, then add the NVMe SSD preset as a second record for PCIe drives. Never mix rows from different presets into one imagined result.
Step 9: Run the test and hands off. Confirm the drive letter one more time, check free space, then click the large All button. All runs every row in the current configuration, while a row’s own button runs only that item. Do not browse, copy files, open games, or let the laptop sleep during the run. If you must stop, use the Stop control and wait for it to finish before doing anything else. An interrupted run is a failed run, and you should discard it instead of comparing partial numbers.
The result grid fills as each row completes. Reads typically finish first, and writes follow. A text export of the same data looks like the layout below. The values here are placeholders to show the format only, so do not read them as a measurement of any drive.
CrystalDiskMark 9.0.3 x64
[Read]
SEQ 1MiB (Q= 8, T= 1): <MB/s> MB/s [ <IOPS> IOPS] < <latency> us>
SEQ 1MiB (Q= 1, T= 1): <MB/s> MB/s [ <IOPS> IOPS] < <latency> us>
RND 4KiB (Q= 32, T= 1): <MB/s> MB/s [ <IOPS> IOPS] < <latency> us>
RND 4KiB (Q= 1, T= 1): <MB/s> MB/s [ <IOPS> IOPS] < <latency> us>
[Write]
SEQ 1MiB (Q= 8, T= 1): <MB/s> MB/s [ <IOPS> IOPS] < <latency> us>
...Your real file will carry more header lines, including the test size, run count, target drive, and timestamp. Exact spacing can shift between versions, which is why the parser you build in Step 13 tolerates optional columns and extra whitespace instead of matching fixed positions.
Step 10: Read SEQ1M, RND4K, Queue Depth, and Thread Counts
Each row label packs four facts. SEQ or RND names the access pattern, sequential or random. The next token is the block size, so 1M means 1 MiB per request and 4K means 4 KiB. Q is the queue depth, the number of requests kept in flight. T is the thread count issuing them. Read the label before you read the number, because SEQ1M Q8T1 and RND4K Q1T1 are different experiments and a big gap between them is normal, not a defect.
| Row | What it stresses | Real-world analogue | Do not conclude |
|---|---|---|---|
| SEQ1M Q8T1 | Large transfers with several requests in flight | Copying big video files, installing large games | That every game or app loads this fast |
| SEQ1M Q1T1 | Large transfers one request at a time | Simple single-stream file copies | That it equals the box rating |
| RND4K Q32T1 | Small random requests with deep queue | Busy servers, many background tasks | That desktop apps ever reach this queue depth |
| RND4K Q1T1 | Small random requests one at a time | Booting Windows, launching apps, snappy feel | That a better score multiplies boot speed |
| RND4K Q32T16 | Small random requests across many threads | Heavy parallel workloads | That one thread can ever match it |
The random 4K rows at queue depth 1 matter most for how a PC feels, because ordinary desktop work asks the drive for small pieces one at a time. This is where latency shows up. A lower microsecond figure at Q1T1 usually means a more responsive system, though CPU, memory, and file caching also play a part. Do not translate a modest random-read gain into a promise of faster boots. The relationship is loose, and anyone claiming a fixed multiple is guessing.
Throughput and IOPS describe the same activity in different units, which you can convert when the block size is fixed. The arithmetic below is a teaching example, not a measurement of any drive. It shows why a random 4 KiB row looks tiny in MB/s even when it posts huge IOPS.
# 4 KiB blocks: IOPS to MB/s
10,000 IOPS x 4,096 bytes = 40,960,000 bytes/s = 40.96 MB/s
# 1 MiB blocks: MB/s to IOPS
3,000,000,000 bytes/s / 1,048,576 bytes = about 2,861 IOPSLatency has its own trap. At queue depth 1, average latency in microseconds is roughly the inverse of IOPS. At higher queue depths, dividing 1 by IOPS no longer gives per-request latency because many requests overlap. If you compare latency across drives, match the queue depth and thread count first. When the sequential rows land near the ceiling of your interface and the random rows look healthy for the drive class, the SATA-versus-NVMe ceilings in our NVMe vs SATA benchmark breakdown give you a reference for what each interface can reach.
Step 11: Compare Your Results With the Spec Sheet Fairly
Once you have a clean result, line it up against the manufacturer’s rating, but do it with care. A mismatch does not automatically mean a defect. Work through these checks in order before you decide anything, and change only one variable at a time as you go.
- Match the capacity variant. Vendors often publish one headline speed for a whole product family, but smaller capacities carry fewer flash chips and can write slower. Compare against the row for your exact capacity.
- Match the interface. Check the Transfer Mode line in CrystalDiskInfo. A drive rated for a fast PCIe link will post lower numbers if it negotiated a slower generation or fewer lanes.
- Check slot sharing. Some motherboards share lanes between M.2 slots and SATA ports or the chipset. Your motherboard manual shows which slot is wired straight to the CPU.
- Check the cache state. A nearly full drive has less fast cache available, so write rows can fall well under the rating while reads stay normal.
- Check temperature. Compare the drive temperature before and after the run. A sharp rise paired with falling write speed points to thermal throttling.
- Check the whole chain for external drives. The enclosure bridge chip, the cable, and the host port each set a ceiling.
External drives deserve extra suspicion. A portable SSD rated for high speeds can land far below that rating on a port with a lower USB speed or with a cheap cable. Our portable NVMe SSD comparison of the P9, P7, and T9 shows how much the product class matters, and the DIY NVMe enclosure versus portable SSD test explains why a bare M.2 drive in a budget enclosure can land far from its internal results. If you test the same bare drive internally and externally, expect the enclosure chain to cost you speed.
A single low score never justifies a return on its own. The sensible path is to save reproducible evidence, rule out the cable and slot, and then contact support with logs. Vendors respond better to a record of three matching runs, a drive firmware string, and a CrystalDiskInfo screenshot than to a forum-style complaint. That evidence package is exactly what the project in Step 13 produces for you automatically.
Step 12: Repeat the Run, Save the Output, and Verify Copy Integrity
One run is a single sample. Take a second under identical conditions, wait a few minutes between them so the drive cools, and compare. If the two runs disagree sharply, investigate the environment before running more tests. Background indexing, a sleeping laptop, or a thermal swing are the usual culprits. Do not simply pick the better run and call it the result.
Save the evidence while the window still shows it. The File menu offers text and image export options. Save both, and name them with the date, the drive model, the preset, and the CrystalDiskMark version, for example 2026-10-28_ModelName_NVMe-preset_cdm-9.0.3.txt. The text file feeds the parser in Step 13. The image is the human-friendly copy for forum posts or support tickets. Before you share any screenshot, check it for your username, volume labels, and serial numbers.
Speed does not prove correctness. If you are benchmarking a drive you plan to trust with a migration, verify that data survives a copy. Hash a sample file at the source and again at the destination and compare the two strings. The check covers the file you hashed, not the whole drive, so it supports a decision about one transfer rather than about the SSD overall.
Get-FileHash -LiteralPath 'C:\BenchSource\sample.bin' -Algorithm SHA256
Get-FileHash -LiteralPath 'D:\BenchCopy\sample.bin' -Algorithm SHA256Confirm that the two paths point to different locations, because hashing the same file twice proves nothing. If the hashes differ after a straightforward copy, stop using that path for important data and check the cable, the port, and the drive status in CrystalDiskInfo. A fast but corrupting path is worse than a slow honest one.
Step 13: Build a Complete Working Benchmark Log Project
This final step ties the routine into a repeatable system. You will create C:\BenchLog with three PowerShell scripts. The first records the environment for a target drive. The second parses a saved CrystalDiskMark text file and appends rows to a CSV. The third compares the latest run with your first baseline and flags large drops. Open an elevated PowerShell window and create the folders.
New-Item -ItemType Directory -Force -Path C:\BenchLog\records, C:\BenchLog\results | Out-Null
Set-Location C:\BenchLogScript 1, New-BenchRecord.ps1. It takes a drive letter, looks up the volume, partition, disk, and physical disk, and writes a JSON record that includes the model, bus type, firmware, only the last four characters of the serial number, free space, power plan, and whether the machine has a battery. Trimming the serial keeps the record safe to share.
param(
[Parameter(Mandatory)][ValidatePattern('^[A-Za-z]$')][string]$DriveLetter,
[string]$Out = 'C:\BenchLog\records'
)
New-Item -ItemType Directory -Force -Path $Out | Out-Null
$letter = $DriveLetter.ToUpper()
$vol = Get-Volume -DriveLetter $letter
$disk = Get-Partition -DriveLetter $letter | Get-Disk
$phys = Get-PhysicalDisk | Where-Object { [int]$_.DeviceId -eq $disk.Number }
$plan = (powercfg /getactivescheme) -replace '^.*:\s*', ''
$battery = [bool](Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue)
$serial = if ($phys.SerialNumber) { $phys.SerialNumber.Trim() } else { '' }
$tail = if ($serial.Length -ge 4) { $serial.Substring($serial.Length - 4) } else { $serial }
$record = [ordered]@{
Timestamp = (Get-Date).ToString('s')
DriveLetter = $letter
DriveModel = $phys.FriendlyName
BusType = [string]$phys.BusType
MediaType = [string]$phys.MediaType
Firmware = $phys.FirmwareVersion
SerialTail = $tail
SizeGB = [math]::Round($vol.Size / 1e9, 1)
FreeGB = [math]::Round($vol.SizeRemaining / 1e9, 1)
FileSystem = $vol.FileSystem
PowerPlan = $plan
HasBattery = $battery
OS = (Get-CimInstance Win32_OperatingSystem).Caption
}
$file = Join-Path $Out ('{0}-{1}.json' -f (Get-Date -Format 'yyyyMMdd-HHmmss'), $letter)
$record | ConvertTo-Json | Set-Content -LiteralPath $file -Encoding UTF8
Write-Output $fileScript 2, Import-CdmResult.ps1. It reads the text export, finds the CrystalDiskMark version, and walks the file line by line. A line that starts with [Read], [Write], or [Mix sets the current section. A line that matches the row pattern becomes an object. IOPS and latency are optional in the pattern, so a layout that omits them still parses. Each row merges with the environment record and appends to results.csv.
param(
[Parameter(Mandatory)][string]$ResultFile,
[Parameter(Mandatory)][string]$RecordFile,
[string]$Preset = 'Default',
[string]$TestSize = '1GiB',
[string]$Csv = 'C:\BenchLog\results\results.csv'
)
$text = Get-Content -LiteralPath $ResultFile -Raw
$record = Get-Content -LiteralPath $RecordFile -Raw | ConvertFrom-Json
$version = if ($text -match 'CrystalDiskMark\s+([\d.]+)') { $Matches[1] } else { 'unknown' }
$pattern = '^\s*(SEQ|RND)\s+(\d+)\s*(KiB|MiB)\s*\(Q=\s*(\d+),\s*T=\s*(\d+)\):\s*([\d.]+)\s*MB/s(?:\s*\[\s*([\d.]+)\s*IOPS\])?(?:\s*<\s*([\d.]+)\s*us>)?'
$section = ''
$rows = foreach ($line in ($text -split "`r?`n")) {
if ($line -match '^\[(Read|Write|Mix)') {
$section = $Matches[1]
continue
}
if ($line -match $pattern) {
[pscustomobject]@{
Timestamp = $record.Timestamp
DriveModel = $record.DriveModel
BusType = $record.BusType
Firmware = $record.Firmware
CdmVersion = $version
Preset = $Preset
TestSize = $TestSize
Direction = $section
Test = '{0}{1}{2}_Q{3}T{4}' -f $Matches[1], $Matches[2], $Matches[3], $Matches[4], $Matches[5]
MBps = [double]$Matches[6]
IOPS = $Matches[7]
LatencyUs = $Matches[8]
FreeGB = $record.FreeGB
PowerPlan = $record.PowerPlan
}
}
}
if (-not $rows) { throw "No result rows parsed from $ResultFile. Check the export layout." }
$rows | Export-Csv -Path $Csv -NoTypeInformation -Append
"{0} rows appended to {1}" -f @($rows).Count, $CsvScript 3, Compare-Bench.ps1. It groups rows by drive, preset, test size, direction, and test label. For each group it treats the earliest row as the baseline, compares the newest row, and flags any drop larger than a threshold you control. The 15 percent default is an editorial starting point, not an industry standard, so tune it to the run-to-run noise you see on your own machine.
param(
[string]$Csv = 'C:\BenchLog\results\results.csv',
[double]$DropPercent = 15
)
$data = Import-Csv -Path $Csv
$groups = $data | Group-Object DriveModel, Preset, TestSize, Direction, Test
$report = foreach ($g in $groups) {
$ordered = @($g.Group | Sort-Object Timestamp)
if ($ordered.Count -lt 2) { continue }
$base = [double]$ordered[0].MBps
$last = [double]$ordered[-1].MBps
if ($base -le 0) { continue }
$change = [math]::Round((($last - $base) / $base) * 100, 1)
[pscustomobject]@{
Drive = $ordered[0].DriveModel
Preset = $ordered[0].Preset
Direction = $ordered[0].Direction
Test = $ordered[0].Test
Baseline = $base
Latest = $last
ChangePct = $change
Flag = if ($change -le -$DropPercent) { 'REVIEW' } else { 'ok' }
}
}
$report | Sort-Object Drive, Direction, Test | Format-Table -AutoSizeThe workflow takes about three minutes once the scripts exist. Before each benchmark, run Script 1 and note the JSON path it prints. After the benchmark, save the text export, run Script 2 with both paths, and run Script 3 to see the comparison. Replace the file names below with your own.
.\New-BenchRecord.ps1 -DriveLetter D
.\Import-CdmResult.ps1 -ResultFile C:\BenchLog\results\2026-10-28_cdm.txt -RecordFile C:\BenchLog\records\20261028-101500-D.json -Preset NVMe
.\Compare-Bench.ps1 -DropPercent 15On the first run, Compare-Bench prints nothing, because each group has only one row and no baseline exists to compare against. That is correct behavior. From the second run onward it prints a table with one line per test, showing the baseline, the latest value, the percentage change, and a flag. The sample below uses placeholders to show the layout.
Drive Preset Direction Test Baseline Latest ChangePct Flag
----- ------ --------- ---- -------- ------ --------- ----
<drive model> NVMe Read SEQ1MiB_Q8T1 <value> <value> <pct> ok
<drive model> NVMe Write SEQ1MiB_Q8T1 <value> <value> <pct> REVIEWTreat a REVIEW flag as a prompt, not a verdict. Check free space, temperature, the power plan recorded in the CSV, and whether the firmware string changed. If the cause is a nearly full drive or a laptop on battery, the numbers will recover once you fix the condition. If nothing explains it and CrystalDiskInfo shows new warnings, back up and contact the vendor. Keep the scripts in a Git repository or cloud folder so a reinstall never costs you your baseline.
Common Pitfalls That Ruin an SSD Speed Test
Most bad benchmark conclusions trace back to a handful of avoidable mistakes. Check this list before you decide anything is broken.
- Testing the system drive while Windows is busy. Windows Update, Defender scans, and indexing all compete for the disk. Wait until Task Manager shows near-zero disk activity before pressing All.
- Comparing screenshots from different versions. The developer warns that results are not compatible across major versions, so a chart from an old release cannot be matched row for row against 9.0.3.
- Reading only the biggest number. A headline sequential read says little about how a drive handles small random work. Look at every row, especially RND4K Q1T1.
- Using 0 Fill and calling it a real score. Compressible data can inflate results on some controllers. Stay on Random for any honest comparison.
- Testing on battery or in a power-saver mode. Laptops may limit PCIe power states and CPU speed, which lowers storage results. Record the power mode and keep it constant.
- Forgetting the drive is nearly full. Free space shapes the fast write cache, so a packed drive posts weaker write rows than a fresh one.
- Running endless loops. Each run writes real data. Nine passes at 64 GiB is a lot of wear for no new information. Three clean runs beat thirty noisy ones.
- Confusing a benchmark with a health scan. A great score does not prove the drive is healthy, and it cannot justify deleting your backups.
One related mistake involves buying decisions. People sometimes swap a hard drive for an SSD, run CrystalDiskMark, and expect the sequential gain to explain every improvement in daily use. Boot and app launch times depend on far more than throughput. Our SSD vs HDD comparison breaks down where the real-world gain comes from and where it does not.
Troubleshooting: 10 Problems and How to Fix Them
| Symptom | Likely cause | Fix |
|---|---|---|
| Sequential speeds far below the rating | Drive negotiated a slower link or fewer PCIe lanes | Check Transfer Mode in CrystalDiskInfo, move the drive to a CPU-attached M.2 slot, update the BIOS |
| Cannot create the test file | No write permission, read-only volume, or no free space | Pick a volume you can write to, free up space, or run from a normal folder |
| Network drive missing from the list | CrystalDiskMark is running as Administrator | Close it and relaunch as a standard user |
| Write speed starts high then collapses | Fast cache exhausted or drive overheating | Check free space and temperature, add a heatsink, retest after cooling |
| Results swing between runs | Background tasks, power saving, or thermal drift | Pause sync and updates, use AC power, wait between runs |
| External drive disconnects mid-test | Bad cable, underpowered port, or unstable enclosure | Stop repeating the test, try another cable and a direct port, then retest |
| Speeds fall to zero with I/O errors | Failing drive or media errors | Stop at once, back up what you can, check CrystalDiskInfo, contact the vendor |
| Drive does not appear in the list | No drive letter or uninitialized disk | Check Disk Management, assign a letter, and do not initialize a disk that holds data |
| Score looks great but file copies feel slow | Copy path limited by source drive, many small files, antivirus, or network | Test the source and destination separately and measure the copy itself |
| Parser throws “No result rows parsed” | Export layout differs or the wrong file was passed | Open the text file, compare the row format to the pattern, and adjust the regex |
Two of these deserve a deeper note. First, if an external drive disconnects, stop benchmarking. Repeated runs on an unstable connection can corrupt data and teach you nothing. Fix the physical path first. Second, if the drive reports a health warning at any point, switch from performance mode to data-protection mode. Our portable NVMe SSD price guide is a helpful reference if the investigation ends with a replacement purchase.
Avoid the temptation to change AHCI, RAID, or VMD modes in the BIOS just to chase a score. That change can stop an existing Windows install from booting. Skip Secure Erase, formatting, and unverified firmware updates until you know the cause. Every one of those steps is easy to start and hard to undo, and none of them is a sensible first response to a single low number.
Advanced Tips for Deeper SSD Benchmarking
Use Peak and Real World Profiles on Purpose
Once the Default baseline is saved, add the Peak Performance profile to see maximum throughput under heavy queue and thread combinations, and the Real World Performance profile to see everyday single-queue behavior. Log each in a separate record with the profile name in the Preset field of the import script. The Mix variants add a column with simultaneous reads and writes, defaulting to 70 percent read and 30 percent write. That column is the closest the tool gets to a busy desktop, because real systems rarely read and write in isolation. Remember that Real World is still a synthetic profile and cannot replace timing your own project or game load.
Study Sustained Writes and Thermals
To see what happens after the fast cache fills, raise the test size on purpose and watch the write rows. Record the temperature before and after each run, and keep the run count low to limit wear. If write speed drops sharply while the temperature climbs, a heatsink or better airflow may restore it. Label every large-size run clearly and never compare it to a 1 GiB run. The built-in cable M.2 enclosure comparison shows how enclosure design changes heat and speed in external setups.
Test NAS Shares and Build a Fleet Habit
For a NAS or file server share, launch CrystalDiskMark as a standard user, map the share, and select it from the drive list. Network results reflect the protocol, the switch, the cable, and the server’s disk together, so record the whole chain in your log. If you manage several PCs, run the same three scripts on each, keep the CSVs in a shared folder, and sort by drive model to spot machines that fall behind their peers. More hardware walkthroughs like this one live in our hardware section.
The takeaway: one screenshot proves little, but a versioned, repeatable log proves a lot. Keep the version, the preset, the size, and the conditions identical, change one variable at a time, and let the numbers settle disputes with vendors and with your own memory.
Frequently Asked Questions About the CrystalDiskMark SSD Speed Test
What is the latest version of CrystalDiskMark? As of October 28, 2026, the official site lists CrystalDiskMark 9.0.3 as the newest build, and no later release appears. CrystalDiskInfo is a separate tool whose newest version is 9.9.3, released October 11, 2026.
Is CrystalDiskMark safe for my SSD? A normal run is safe, but it writes data, so each pass consumes a tiny part of the drive’s write endurance. Avoid long loops at large sizes without a reason, and back up first. Do not benchmark a drive that already reports Caution or Bad.
Which preset should I use for an NVMe SSD? Start with Default so your result matches common baselines, then add the NVMe SSD preset to load the drive with deeper random work. Record them as separate runs and never merge rows across presets.
Why is my speed lower than the number on the box? The rating usually describes a best-case sequential read on a specific capacity and slot. Your result can fall lower because of a smaller capacity variant, a slower negotiated link, a shared lane, a full drive, high temperature, or an enclosure bottleneck. Work through those checks before assuming a defect.
What do Q and T mean in the result rows? Q is queue depth, the number of requests kept in flight, and T is the number of threads issuing them. A label such as RND4K Q1T1 means random 4 KiB requests, one at a time from a single thread, which is the closest match for everyday desktop responsiveness.
Does CrystalDiskMark check drive health? No. It measures speed only. Use CrystalDiskInfo or vendor diagnostics to read S.M.A.R.T. data, temperature, and status. The All 0x00 option is a test data pattern and not a sector health scan.
Can I use CrystalDiskMark on a Mac or Linux? CrystalDiskMark itself is a Windows program. Community tools such as AmorphousDiskMark for macOS and KDiskMark for Linux mimic its layout, as reported by WindowsForum in October 2026. Their numbers are not directly comparable with the Windows tool.
How often should I benchmark my SSD? Benchmarking does not maintain or repair a drive, so there is no need to run it on a schedule. Record a baseline when you install the drive, repeat after major changes such as new firmware or a new enclosure, and run it again whenever the machine feels slower.
