Memtest86+ v9.00 shipped on October 15, 2026, and its headline addition is a DDR5-oriented bus-stress test built to catch interface errors that short passes miss, according to Hardware Busters’ release coverage. That timing matters. Enabling XMP or EXPO is a memory overclock, and a kit that boots into Windows can still corrupt a file an hour later.
This guide covers the whole loop in 13 steps. You enable the profile (if you have not yet, our XMP and EXPO BIOS walkthrough covers that side), build a bootable Memtest86+ stick, run a Memtest86 RAM test long enough to mean something, and log each result so you compare profiles on evidence instead of gut feel. Plan on roughly 60 minutes of hands-on work. The burn-in runs unattended, usually overnight.
Two nearby posts on this site cover different ground. Our gaming-crash guide uses PassMark’s commercial tool to diagnose a PC that already crashes. This tutorial targets the opposite case: a healthy PC where you just switched on a DDR5 profile and need to know whether it holds. It also uses the free, open-source Memtest86+ project, which is a separate product despite the near-identical name.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Memtest86+ v9.00 Changes for DDR5 Testing
Memtest86+ is a free memory tester that boots on its own, outside Windows or Linux, so the operating system cannot hide or absorb errors. As of October 25, 2026, v9.00 is the current release. The project describes it as its largest release since the v6 rewrite, and it adds Intel Wildcat Lake support alongside the DDR5 work. Reportedly, v8.10 landed in May 2026 and v8.00 in November 2025, so anyone still running a stick built from those releases is missing the new DDR5 test.
The table below lists the v9.00 changes that matter when you validate a memory profile. All of them come from the project’s release notes and the independent coverage of the release.
| v9.00 feature | What it does | Why it matters for XMP or EXPO |
|---|---|---|
| DDR5 bus-stress test | Hammers the memory interface rather than only the storage cells | Targets profile instability that conventional passes can miss |
| Optional RowHammer test | Probes for bit flips from repeated row access | Optional, so you choose whether the extra time is worth it |
| Redesigned tests | Reworks the test set | A fresh baseline, so rerun old profiles with the new build |
| USB report saving | Writes results to a USB drive | Lets you keep proof of each run for your ledger |
| Startup SPD checks | Flags corrupted SPD data at boot | Catches a kit whose stored profile data is damaged before you blame the BIOS |
| ARM64 support | Runs on Arm hardware | Irrelevant to most DDR5 desktops, but it widens the tool’s reach |
The bus-stress test is the one to care about. DDR5 profile trouble often sits in the signal path between the memory controller and the modules, not in the cells themselves. Independent coverage points out that the new test suits exactly the instability that aggressive XMP or EXPO settings create. Treat that as the project’s stated intent rather than a guarantee, since no test proves a negative.
One naming trap deserves attention. PassMark sells a commercial tool called MemTest86, and it is a separate product from the open-source Memtest86+ project. Do not mix up their names or their instructions. Part of this guide compares the two so you can pick deliberately.
On the standards side, I found no announced successor to either profile format. Intel’s XMP 3.0 remains the DDR5 version, and according to Intel’s FAQ it supports up to five profiles, while XMP 2.0 belongs to DDR4. AMD’s EXPO remains the AM5 equivalent, and AMD said at Computex 2026 that it will keep supporting AM5 through 2029. The workflow here applies to both camps.
Prerequisites and Versions
Gather everything before you touch the BIOS. A missing second USB stick or a BIOS flash started at the wrong moment ruins more tuning sessions than bad RAM does.
| Item | Requirement | Notes |
|---|---|---|
| Memtest86+ | v9.00 (released Oct 15, 2026) | Open source, free. Do not substitute PassMark MemTest86 here |
| Platform | DDR5 desktop with Intel XMP 3.0 or AMD EXPO profile | AM5 boards such as those paired with a Ryzen 9 9950X3D qualify |
| Firmware | Latest stable UEFI for your board | Memory training improves with updates |
| USB stick one | Any stick you can erase | Holds the Memtest86+ boot image |
| USB stick two | Small stick for saved reports | Reportedly works best formatted FAT32 |
| Host OS | Windows 11 or a current Linux distro | Used only to read settings and write the stick |
| Python | 3.10 or newer | Runs the ledger script in the project section |
| Monitoring | Latest CPU-Z (optional) | Cross-check of speed and timings inside the OS |
| Time | About 60 minutes hands-on, plus an unattended burn-in | Run the burn-in overnight |
Two safety notes before you begin. First, back up anything important. A failed memory test cannot damage data by itself, but an unstable profile you left enabled can, and you are about to run unstable profiles on purpose. Second, write down your current BIOS settings or take photos. If a setting change leaves the board refusing to boot, you will want to know what “normal” looked like. Browse the hardware section if you need a reset procedure for your specific board.
Also check the kit itself. Find the full part number printed on the label and compare it with your motherboard’s qualified vendor list (QVL). A kit missing from the QVL can still work, but it earns less benefit of the doubt when errors appear. Replacing a bad kit costs real money right now, so it pays to know early. Our look at DDR5 pricing under AI demand shows what a swap could cost.
Steps 1 to 3: Baseline, BIOS, and Profile
Start by measuring what you have. These first three steps cost ten minutes and save hours of confusion later, because they give you a “before” reading to compare against.
Step 1: Record your baseline memory settings
Read the current speed, voltage, and module list from inside the operating system. On Windows, open PowerShell and run:
Get-CimInstance Win32_PhysicalMemory |
Select-Object BankLabel, Manufacturer, PartNumber, Capacity, Speed, ConfiguredClockSpeed, ConfiguredVoltage |
Format-Table -AutoSizeOn Linux, use dmidecode, which needs root:
sudo dmidecode -t memory | grep -E "Size|Locator:|Speed|Voltage|Part Number"Look at two fields in particular. “Speed” reports what the module claims it can do, while “Configured Memory Speed” (or ConfiguredClockSpeed on Windows) reports what the board actually runs. If the configured number sits well below the kit’s label, such as 4800 MT/s on a DDR5-6000 kit, your profile is off. That is normal on a fresh build, because boards fall back to a safe default until you opt in.
A DDR5-6000 label does not describe a plug-and-play standard speed. It describes an overclocking profile that you must enable in firmware, which is the core reason this whole guide exists.
Save the output to a text file. Name it baseline.txt and keep it next to your future reports.
Step 2: Update the BIOS and verify the install
Check your board maker’s support page for a newer stable UEFI and flash it using the vendor’s documented method. Skip beta builds unless a specific memory fix needs one. Memory training behavior shifts between firmware releases, and a stable release is the best-tested starting point.
Then confirm physical installation. With two modules, use the slots your board manual recommends, which on most four-slot boards are the second and fourth from the CPU (often labeled A2 and B2). If you need a refresher on seating the sticks, our RAM installation walkthrough covers latch alignment and the click you should hear.
A quick word on four-module builds. Populating all four slots on AM5 can force the memory far below the advertised speed and can break EXPO stability, as a WindowsForum thread on four-stick AM5 systems describes, with speeds dropping as low as 3600 in the cases it discusses. If you run four sticks, expect to test at lower speeds than the label.
Step 3: Enable the XMP or EXPO profile and save
Reboot into the UEFI setup, usually by tapping Delete or F2 during POST. Find the memory section, often under an “AI Tweaker,” “OC,” “Tweaker,” or “Extreme Tweaker” tab, and choose the profile. Intel boards label it XMP and AMD boards label it EXPO. Pick the first profile unless you know what the others do. Some kits carry a tuned second profile with tighter timings. If your kit carries AMD’s lower-latency EXPO ULL variant, our EXPO ULL setup guide explains the differences.
Save and exit. Expect the first boot to take noticeably longer than usual. The board performs memory training on DDR5, and a slow first boot with a blank screen is normal, not a failure. Give it a couple of minutes before you consider a reset.
Back in the operating system, repeat Step 1 and compare. The configured speed should now match the label. If it does not, fix that first (see the troubleshooting table below) before you start the Memtest86 RAM test, since testing the wrong configuration wastes a night.
Do not stop here. A profile that boots has passed the lowest bar available. It has not shown that it can hold under sustained, adversarial access patterns, which is exactly what the next steps measure.
Steps 4 to 6: Download, Build the Boot Stick, Prepare Reports
Now you build the tool. Everything here happens on a second computer or on your current PC before you reboot, and none of it touches your RAM settings.
Step 4: Download Memtest86+ v9.00 and check what you got
Get the build from the project itself, not from a mirror site you stumbled on. The v9.00 release page on GitHub hosts the official assets, and the project site at memtest.org points to the same release. Download the USB image archive for most desktops. The ISO is the alternative if you prefer burning optical media or booting through a virtual drive on a KVM.
Check the version label in the file name. If it says anything other than 9.00, you grabbed an older build, and you would miss the DDR5 bus-stress test entirely. Search results still surface old v7 and v8 tutorials, and those instructions describe older menus.
Verify integrity before you write anything to a stick. If the release page lists checksums, compare them. On Linux or macOS, run sha256sum on the archive. On Windows PowerShell, Get-FileHash does the same job:
Get-FileHash .\memtest86plus-usb.zip -Algorithm SHA256Replace the file name with whatever you downloaded. A mismatch means a corrupted or tampered download, and you should fetch it again over a clean connection.
Unzip the archive. Inside you will find a raw disk image with an .img extension. That file goes onto the stick.
Step 5: Write the bootable USB stick
This step erases the target stick completely, so identify it carefully. Writing to the wrong drive destroys data, and no undo exists.
On Windows, a graphical writer such as Rufus handles this. Select the .img file and choose DD image mode if the tool asks how to write it. Double-check that the selected device is your blank stick by size.
On Linux, start by listing block devices:
lsblk -o NAME,SIZE,MODEL,TRANFind the stick by its size and its usb transport. Suppose it shows up as /dev/sdX. Unmount any mounted partitions, then write the image:
sudo umount /dev/sdX* 2>/dev/null
sudo dd if=memtest86plus.img of=/dev/sdX bs=4M status=progress conv=fsync
syncReplace sdX with the real device name, with no partition number. If you type sda and your system disk is sda, you have just wiped your operating system. Read the lsblk output twice. The conv=fsync flag forces the write to finish, and the final sync flushes buffers, so wait for both before you pull the stick.
Label the stick with tape: “Memtest86+ v9.00”. Next year’s you will thank today’s you.
Step 6: Prepare the reports stick
The v9.00 release can save test reports to a USB drive, which gives you a record per run instead of a photo of a screen. Reportedly the target should be formatted FAT32. Use a second, small stick for this, so you never risk overwriting your boot image.
On Windows, you can format from File Explorer by choosing FAT32 in the format dialog. Note that Windows’ own tool may refuse FAT32 on larger drives. If you hit that wall, a stick of 32 GB or smaller usually formats without trouble, and any old stick fits the job since reports are tiny.
On Linux:
sudo mkfs.vfat -F 32 -n MT86REPORT /dev/sdY1Again, double-check the device letter. Create a folder called runs on the stick. You will copy each report into a dated subfolder later, then log the key numbers in the ledger from the project section.
Keep both sticks plugged in during testing only if the interface allows it. Some boards boot more reliably with a single stick in a rear port and the second added after the menu loads.
Steps 7 to 9: Boot, Configure, and Run the Memtest86 RAM Test
This is the part where mistakes get expensive in time. Slow down, set the options deliberately, and start the run only after you have confirmed what the screen says.
Step 7: Boot from the stick
Shut down fully, plug in the Memtest86+ stick, and tap your board’s boot-menu key during POST (commonly F8, F11, or F12 depending on the vendor). Choose the stick. If it appears twice, once as UEFI and once as legacy, pick the entry with “UEFI” in the name on any modern DDR5 board, since those boards boot in UEFI mode.
Secure Boot can block the boot. Reportedly, the v9 binaries are signed with the project’s own certificate authority, and Microsoft’s signing was still described as hoped-for rather than done in October 2026. In plain terms, a board with Secure Boot enforced may refuse the stick. Disable Secure Boot in firmware for the test, then turn it back on afterward. If your motherboard lets you enroll a custom key instead, that route works too, though it takes more care.
If the keyboard does not respond once Memtest86+ loads, look at USB settings in firmware. Legacy USB support or an xHCI hand-off option sometimes needs a toggle. A PS/2 or different port often fixes it as well.
A healthy start looks like a text screen listing your CPU, the detected memory size, and memory timings. Read these lines. The detected speed here should match the profile you enabled. If the screen shows a lower speed than the profile promises, your Step 3 save did not stick, and you should stop and fix that before testing.
Step 8: Configure the run
Open the configuration menu using the key the on-screen legend shows. Three choices matter.
First, confirm the DDR5 bus-stress test is included in the test selection. It is the v9.00 headline feature and the reason you downloaded this build, so leave it on. Second, decide about the RowHammer test. It is optional in v9.00, and reportedly disabled by default. Enable it on your final candidate profile in the burn-in phase, not on every experiment, since each added test lengthens the run. Third, set the number of passes. For a first look, one pass tells you whether the profile is grossly broken. For acceptance, plan on at least four.
Also note the CPU selection setting. Leave multi-threaded testing on, since a single core often cannot generate enough traffic to expose bus-level trouble.
Do not change addresses, timings, or voltage inside the tester. It reports the memory state, and your tuning belongs in firmware.
Step 9: Run the first pass and watch it
Start the run. Memtest86+ keeps a live counter of errors and a pass indicator on screen. Watch the first ten minutes, because bad profiles often fail quickly. A profile that throws errors within minutes is badly out of range, and you can abort, drop the speed one step in firmware, and try again without waiting for the whole pass.
If the screen stays clean through a complete pass, you have cleared the first gate only. Note the elapsed time, because it scales with memory capacity and speed. Larger kits take longer than smaller ones, and a slower profile takes longer than a faster one, so your own first-pass time is the number you need for planning the overnight burn.
Keep the machine’s environment steady. A closed case in a warm room runs the modules hotter than an open bench, and heat influences marginal DDR5 behavior. You want the test to resemble the conditions where you will actually use the PC, so avoid cooling the test environment artificially unless you plan to run the PC that way.
While waiting, write the first row of your ledger by hand: profile name, configured speed, voltage, and pass count. The project section automates this, but the habit of recording before you see results keeps you honest.
Steps 10 and 11: Read the Results and Compare Profiles
A Memtest86 RAM test only helps when you interpret it correctly. Zero errors and a few errors mean very different things, and the number of errors matters less than the pattern.
Step 10: Read the verdict
When the run ends, the screen shows the pass count and any errors. Copy the report to your reports stick if you have it connected, then photograph the screen as a backup.
Interpret the outcome in three tiers:
- Zero errors across all passes. The profile survived this test at this temperature. That is a good sign, and it is the only thing it proves. Move on to burn-in.
- A handful of errors, clustered in a narrow address range. This pattern can point at a single weak module or a damaged region. Swap which module sits in which slot and retest to see whether the errors follow the stick or the slot.
- Many errors, spread across the whole range, appearing within minutes. This usually means the profile asks too much of the memory controller, the board, or the kit. Lower the speed or loosen the profile and test again.
The startup SPD check deserves a glance too. v9.00 checks for corrupted SPD data at launch, so a warning there before any test runs points at the module’s stored profile information, not at your tuning. If you see one, reseat the stick and boot again before you blame anything else.
Do not argue with a failure. The tempting move is to rerun the test hoping it passes, and a profile that fails once and passes later has not become stable. It has gotten lucky. Treat any error as a fail and adjust.
Step 11: Test the baseline, then compare every profile
Run the identical procedure on at least two configurations: the default JEDEC speed with no profile, and your enabled XMP or EXPO profile. The default run is your control. If the default configuration also throws errors, the profile is innocent and a module, slot, or CPU memory controller has a problem independent of your tuning.
This control run catches the case that confuses people most. Without it, a flaky stick looks like a bad overclock, and you spend a week lowering speeds on a module that should be returned.
For each configuration, record in your ledger:
- The label (for example “EXPO 6000 profile 1”)
- The configured speed read from the operating system
- The voltage the board applied
- How many full passes ran
- How many errors appeared
If the full profile fails, step down in measured increments. Drop one speed grade, retest, then repeat until you find the fastest configuration that passes cleanly. Our DDR5 overclocking guide goes deeper on manual timings and voltage if you want to tune beyond the stock profile. Be careful with voltage. Raising it to chase stability can shorten module life and add heat, so change one thing at a time and keep the changes small.
The table below suggests how many passes to demand depending on what the result will be used for. These are practical working figures for planning, not figures from the project, so adjust them to your risk tolerance.
| Purpose | Suggested passes | When it fits |
|---|---|---|
| Quick sanity check | 1 | Right after changing a setting, to catch gross failures |
| Profile acceptance | 4 | Before you trust a profile for daily use |
| Burn-in | 8 or more, unattended | Final candidate, overnight |
| Workstation or data-critical machine | 8 or more, plus RowHammer test | Systems where silent corruption costs real money |
| Gaming PC | 4 to 8 | Balanced check for a machine you can reboot freely |
Steps 12 and 13: Burn In and Lock the Settings
Short tests find fast failures. Marginal profiles tend to fail slowly, so the last two steps trade your time for confidence.
Step 12: Run the overnight burn-in
Take your best candidate and set a long run, using the pass count from the table above. Enable the RowHammer test for this run if you want the extra coverage. Start it before bed and leave the PC alone. Do not let it sleep, since the stick boots into the tester and the machine will run until it finishes or you stop it.
Environmental consistency matters here. Keep the case closed, keep the room at its usual temperature, and leave your normal fan curve active. An accidental bench setup that runs cooler than your living room can hide a profile that fails in summer.
In the morning, copy the report off the reports stick and log the result. A candidate that passed eight overnight passes with the bus-stress test enabled has earned your trust for most uses. A candidate with a single error does not. Drop it one step and burn in again. It is annoying, but another evening of waiting beats a corrupted project file.
Step 13: Lock the settings and verify in the operating system
Boot back into the operating system and confirm that the configured speed still matches your accepted profile. Then run a workload that stresses memory plus the rest of the system. Our CPU and GPU stress test guide pairs well with this, because a full-system load stresses the power delivery and memory controller together, which a standalone memory test does not.
Next, save the profile in your BIOS if your board supports named profiles. Many boards let you store a user profile. Use it, and note the BIOS version in your ledger. A later BIOS update can reset memory settings or change training behavior, so re-run a shorter acceptance test after every firmware update. Four passes is a sensible minimum.
Finally, re-enable Secure Boot if you disabled it, and remove the test sticks. Keep the boot stick in a drawer. You will use it again after your next BIOS update, and again if a crash sends you hunting.
Common Pitfalls When Testing DDR5
Most failed validation runs trace back to a short list of errors. Avoid these six and you will save yourself at least one lost evening.
Pitfall 1: Trusting a boot as proof of stability. A profile that reaches the desktop has passed the lowest possible test. Memory instability appears under load, under heat, or after hours. Only a dedicated test settles the question.
Pitfall 2: Testing inside Windows instead of outside it. In-OS memory testers cannot reach every address, because the operating system and its drivers occupy part of the memory. Booting Memtest86+ from a stick tests nearly the whole range with nothing in the way.
Pitfall 3: Skipping the control run. If you never test default speeds, you cannot tell a bad profile from a bad module. Always test both.
Pitfall 4: Using an old build. Tutorials for v7 and v8 still rank in search results. Those builds lack the v9.00 DDR5 bus-stress test, so a pass on them says less about your DDR5 profile.
Pitfall 5: Mixing up Memtest86+ and MemTest86. The open-source and commercial products share a near-identical name, but they are separate projects with separate versions and licenses. Follow instructions for the one you actually installed.
Pitfall 6: Changing several things at once. If you raise voltage, drop a timing, and change slots in one go, a pass or a fail teaches you nothing. Change one variable per run and log it.
A seventh trap hides in firmware: memory-related options sometimes get reset by a BIOS update or a CMOS clear, so a PC that was stable last month may be running different settings today. Recheck the configured speed after any firmware event.
Troubleshooting: 10 Problems and Fixes
When something breaks, work through this table from the top. The first rows are the most common.
| Symptom | Likely cause | Fix |
|---|---|---|
| Configured speed stays low after enabling the profile | Profile not saved, or board fell back after failed training | Re-enter firmware, reapply the profile, save with the exit command, and check the BIOS version |
| First boot hangs on a black screen | DDR5 memory training in progress | Wait a few minutes before resetting, since training can run long |
| Board loops or boots into recovery after enabling the profile | Profile too aggressive for this board or controller | Clear the setting via the board’s reset method, then try a lower speed |
| Stick will not boot (Secure Boot error) | Secure Boot rejects the project-signed binary | Disable Secure Boot for the test, then re-enable it afterward |
| Keyboard dead in Memtest86+ | Firmware USB handling | Enable legacy USB or xHCI hand-off, or move to a different port |
| Errors within minutes at the profile speed | Profile beyond the kit or controller limit | Drop one speed grade and retest. Compare with the default-speed control run |
| Errors also at default speed | Faulty module, slot, or CPU memory controller | Test one stick at a time in a known-good slot to isolate the culprit |
| Errors only with four modules installed | Four-DIMM load strains the controller | Test at a lower speed, or switch to a two-module kit |
| Passes in Memtest86+ but games crash | Problem elsewhere (GPU, power, storage, drivers) | Run a full-system load and test the power supply before blaming RAM again |
| Reported voltage looks wrong in an OS tool | Value read from firmware tables that the board may report incorrectly | Cross-check the voltage in the UEFI hardware monitor before drawing conclusions |
| SPD warning at startup | Corrupted or unreadable module data | Reseat the module, update the BIOS, and replace the kit if it persists |
A few of these deserve a longer note. Isolation is the most useful technique on the list. With four modules or a flaky system, remove all but one stick, test it in the first recommended slot, then rotate. If errors follow a specific stick, that stick is bad. If errors follow a specific slot, the slot or the CPU socket is the suspect. If errors follow neither, suspect the profile or the controller.
On the voltage row, a PassMark forum discussion updated October 20, 2026 reportedly noted that voltage shown by software may come from BIOS or SMBIOS data, so it can be wrong when firmware reports it badly. A low reading under an enabled profile does not prove the profile failed. Check the UEFI monitor, and if the number still looks off, test the power supply too.
If the problem looks like a motherboard, not memory, you are in territory for the manufacturer’s support channel. Bring your ledger. A table of runs showing which profile fails where gives support staff something to work with.
Memtest86+ vs PassMark MemTest86: Which Should You Run?
Both tools test RAM from outside the operating system, and both detect DDR5 and report XMP or EXPO details. They differ in license, cost, and update cadence. PassMark’s own technical page says its tool supports DDR5 and reads SPD details, including modules that support Intel XMP 3.0 or AMD EXPO profiles, which you can verify on PassMark’s technical page.
| Factor | Memtest86+ v9.00 | PassMark MemTest86 |
|---|---|---|
| Developer | Open-source project | PassMark Software |
| Cost | Free | Commercial, check the vendor’s pricing page |
| Release line | v9.00, Oct 15, 2026 | Separate version numbering, check the vendor page |
| DDR5 bus-stress test | Yes, new in v9.00 | Not confirmed from available sources |
| SPD and profile reporting | SPD corruption checks at startup | Reports DDR5 SPD details, including XMP 3.0 and EXPO support |
| Best for | Profile validation, enthusiasts, Linux users | Users who want a commercial support path |
My practical advice: run both on a profile you intend to rely on. They use different algorithms, so a profile that passes one and fails the other has told you something real. Start with Memtest86+ because v9.00 targets exactly this DDR5 profile scenario. Use PassMark’s tool as a second opinion, and read our earlier gaming-crash walkthrough for how that workflow differs.
According to a PassMark post, a purchased copy keeps working indefinitely, with upgrades and support included for 12 months after purchase. That is worth knowing if you manage several machines, though a home user rarely needs a paid license.
XMP, EXPO, and Four-DIMM Builds: What Changes When You Test
The test procedure stays the same across platforms, but the failure patterns differ. Knowing which platform you are on tells you where to look first.
On Intel boards, XMP 3.0 profiles live on the module and the firmware reads them at boot. According to Intel’s FAQ, a DDR5 module can hold up to five profiles, some of them user-rewritable. That gives you room to experiment, because a kit may ship with more than one tuned entry. Test each stored profile separately and give each its own ledger row. Never assume profile two behaves like profile one.
On AMD AM5 boards, EXPO plays the same role. AMD’s desktop processor pages reportedly still list EXPO memory overclocking support for chips such as the Ryzen 7 9800X3D and Ryzen 7 9850X3D, and the Ryzen 9 9950X3D leads AMD’s current X3D desktop lineup. AMD also announced a lower-latency variant called EXPO ULL at Computex 2026. In its own testing, AMD reportedly said ULL memory could deliver an average 4 percent FPS gain over non-ULL EXPO memory. Treat that number as a vendor claim measured under AMD’s conditions, and verify your own results with the ledger.
The sharpest difference appears when you populate four slots. Two modules put one stick on each channel. Four modules double the electrical load on the memory controller, and the controller usually cannot hold the same speed. The WindowsForum discussion cited earlier describes speeds falling toward 3600 in some AM5 four-stick cases and EXPO profiles becoming unreliable. So the right expectation for a four-module build is a lower target speed and a longer burn-in.
| Scenario | Typical behavior | How to test it |
|---|---|---|
| Two modules, Intel, XMP profile | Usually the easiest case | Standard 13-step run, 4 passes for acceptance |
| Two modules, AM5, EXPO profile | Usually works at the label speed on a supported board | Same run, and log the BIOS version |
| EXPO ULL kit | Tighter latency may leave less headroom | Test ULL and standard EXPO as separate ledger rows |
| Four modules, any platform | Controller load rises, speed often has to drop | Start low, raise gradually, burn in longer |
| Mixed or odd kits | Different ICs and timings clash | Avoid, or test at default speed only |
Keep the kit’s rating in perspective, too. A speed printed on a box is a target the vendor validated on specific platforms. Your CPU’s memory controller, your board’s trace layout, and the BIOS all vary from sample to sample. Two identical PCs can land at different stable speeds, and that is not a defect.
Advanced Tips for Stubborn Kits
Once the basic loop works, these habits separate a casual check from a result you can lean on.
Run a cold-boot test. After a long shutdown, memory training starts from scratch, and some profiles that survive warm restarts fail after the PC sits off overnight. Power down fully for a few minutes, then boot straight into the tester.
Keep a known-good fallback. Save your last passing configuration as a named BIOS profile before you experiment further. If a new attempt fails to boot, you can reload the fallback in seconds instead of reconstructing settings from memory.
Test after every firmware change. BIOS updates can alter memory training. Treat each update as a reason to rerun at least four passes, and log the new version next to the result.
Combine tools. A pass in Memtest86+ plus a pass in PassMark’s tool plus a stable full-system load is stronger evidence than any single test. The full-system stress test covers the load side, and manual RAM overclocking covers the tuning side when stock profiles fall short.
Check single sticks. When errors appear and the cause stays unclear, test each module alone in the first recommended slot. A stick that errors on its own is the culprit, and this single experiment settles more arguments than any amount of forum reading.
Watch temperature, not just speed. DDR5 modules carry their own power management and run warmer than older generations. If errors show up only after an hour, airflow over the modules deserves attention. Adding a small fan or reseating your case fans can change the outcome.
Photograph everything. Take pictures of BIOS memory pages before and after each change. Memory options hide across several tabs, and a photo set saves you when a later update scrambles the menu layout.
Mind the budget. Memory costs real money now, and the temptation to push a marginal kit past its comfort zone is strong. If a profile needs a voltage bump plus loosened timings to pass, you have probably lost the speed advantage you bought the kit for. In that case, a stable lower speed beats an unstable higher one every time.
Complete Working Project: A RAM Profile Ledger
This script ties the tutorial together. Memtest86+ runs outside the operating system, so it cannot write into your ledger directly. Instead, you boot back into Windows or Linux after each run, then call the script with the pass and error counts you read off the screen or the saved report. The script reads the live configured speed and voltage from the operating system, computes a verdict, and appends one row to a CSV file.
It uses only the Python standard library and runs on Python 3.10 or newer. On Linux it calls dmidecode, so run it with sudo. On Windows it calls PowerShell, so run it from a normal terminal.
#!/usr/bin/env python3
"""ramledger.py: log DDR5 profile attempts next to their Memtest86+ results."""
import argparse
import csv
import datetime as dt
import platform
import re
import subprocess
import sys
from pathlib import Path
LEDGER = Path("ram_ledger.csv")
FIELDS = ["date", "label", "target_mts", "configured_mts", "voltage_v",
"dimms", "passes", "errors", "verdict"]
MIN_PASSES = 4
def parse_dmidecode(text):
dimms = []
for block in text.split("\n\n"):
if "Memory Device" not in block or "No Module Installed" in block:
continue
speed = re.search(r"^\s+Configured Memory Speed: (\d+)", block, re.M)
volt = re.search(r"^\s+Configured Voltage: ([\d.]+)", block, re.M)
if speed:
dimms.append({"mts": int(speed.group(1)),
"volt": float(volt.group(1)) if volt else 0.0})
return dimms
def parse_windows(text):
dimms = []
for line in text.strip().splitlines():
mts, volt = [part.strip() for part in line.split(",")]
if mts.isdigit():
dimms.append({"mts": int(mts),
"volt": int(volt or 0) / 1000})
return dimms
def read_dimms():
system = platform.system()
if system == "Linux":
out = subprocess.run(["dmidecode", "-t", "memory"], check=True,
capture_output=True, text=True).stdout
return parse_dmidecode(out)
if system == "Windows":
ps = ("Get-CimInstance Win32_PhysicalMemory | ForEach-Object "
"{ '{0},{1}' -f $_.ConfiguredClockSpeed, $_.ConfiguredVoltage }")
out = subprocess.run(["powershell", "-NoProfile", "-Command", ps],
check=True, capture_output=True, text=True).stdout
return parse_windows(out)
sys.exit("Only Linux and Windows are supported.")
def judge(errors, passes, configured, target):
if errors > 0:
return "FAIL"
if passes < MIN_PASSES:
return "INCOMPLETE"
if configured < target:
return "STABLE-BUT-SLOW"
return "PASS"
def cmd_log(args):
dimms = read_dimms()
if not dimms:
sys.exit("No DIMMs found. On Linux, run with sudo.")
configured = min(d["mts"] for d in dimms)
volts = max(d["volt"] for d in dimms)
row = {
"date": dt.date.today().isoformat(),
"label": args.label,
"target_mts": args.target,
"configured_mts": configured,
"voltage_v": volts,
"dimms": len(dimms),
"passes": args.passes,
"errors": args.errors,
"verdict": judge(args.errors, args.passes, configured, args.target),
}
is_new = not LEDGER.exists()
with LEDGER.open("a", newline="") as fh:
writer = csv.DictWriter(fh, fieldnames=FIELDS)
if is_new:
writer.writeheader()
writer.writerow(row)
print(f"Logged: {row['label']} | {configured} MT/s | {volts} V | "
f"{args.passes} passes | {args.errors} errors | {row['verdict']}")
def cmd_summary(_args):
if not LEDGER.exists():
sys.exit("No ledger yet. Run the log command first.")
with LEDGER.open(newline="") as fh:
rows = list(csv.DictReader(fh))
print(f"{'label':<22}{'MT/s':>6}{'V':>7}{'passes':>8}{'errors':>8} verdict")
for r in rows:
print(f"{r['label']:<22}{r['configured_mts']:>6}{r['voltage_v']:>7}"
f"{r['passes']:>8}{r['errors']:>8} {r['verdict']}")
stable = [r for r in rows if r["verdict"] in ("PASS", "STABLE-BUT-SLOW")]
if stable:
best = max(stable, key=lambda r: int(r["configured_mts"]))
print(f"\nFastest stable profile: {best['label']} "
f"at {best['configured_mts']} MT/s")
else:
print("\nNo stable profile yet. Drop one speed grade and retest.")
def main():
parser = argparse.ArgumentParser(description=__doc__)
sub = parser.add_subparsers(dest="cmd", required=True)
log = sub.add_parser("log", help="read live RAM settings and add a row")
log.add_argument("--label", required=True)
log.add_argument("--target", type=int, required=True,
help="speed on the kit label, in MT/s")
log.add_argument("--passes", type=int, required=True)
log.add_argument("--errors", type=int, required=True)
log.set_defaults(func=cmd_log)
summ = sub.add_parser("summary", help="print the ledger")
summ.set_defaults(func=cmd_summary)
args = parser.parse_args()
args.func(args)
if __name__ == "__main__":
main()Save it as ramledger.py. Then log each run from the terminal. The --target value is the speed printed on the kit label, in MT/s. The script compares it with what the system actually runs:
sudo python3 ramledger.py log --label "JEDEC default" --target 6000 --passes 4 --errors 0
sudo python3 ramledger.py log --label "EXPO 6000 p1" --target 6000 --passes 2 --errors 3
sudo python3 ramledger.py log --label "EXPO 5800 tuned" --target 6000 --passes 8 --errors 0
sudo python3 ramledger.py summaryOn Windows, drop sudo and use python instead of python3. Each log command prints one line, for example:
Logged: EXPO 5800 tuned | 5800 MT/s | 1.35 V | 8 passes | 0 errors | STABLE-BUT-SLOWThe summary command prints the whole ledger and picks the fastest profile with no errors and enough passes. This is example output from the three runs above, using sample values:
label MT/s V passes errors verdict
JEDEC default 4800 1.1 4 0 STABLE-BUT-SLOW
EXPO 6000 p1 6000 1.35 2 3 FAIL
EXPO 5800 tuned 5800 1.35 8 0 STABLE-BUT-SLOW
Fastest stable profile: EXPO 5800 tuned at 5800 MT/sThe verdict logic is deliberately strict. Any error means FAIL, whatever else happened. Fewer than four passes means INCOMPLETE, because a short run proves little. A clean run at a speed below the kit label earns STABLE-BUT-SLOW, which tells you the configuration works but leaves performance on the table. Only a clean run of four or more passes at the target speed returns PASS. You can change the MIN_PASSES constant at the top of the script if your risk tolerance differs.
Three small extensions are worth considering once you trust the base. Add a bios column and a --bios argument so every row carries the firmware version. Add a notes field for the slot layout. And commit the CSV to a private repository, so a clean reinstall does not erase your testing history.
FAQ
How long does a Memtest86 RAM test take?
It depends on installed capacity and memory speed, so no single number fits every PC. Time your first full pass, then multiply by the pass count you want. A 4-pass acceptance run on a large kit can take hours, which is why the overnight burn-in exists.
Is Memtest86+ the same as MemTest86?
No. Memtest86+ is a free, open-source project, and v9.00 is its current release as of October 25, 2026. MemTest86 is a separate commercial product from PassMark Software. They share a similar name and a similar purpose, but they carry different version numbers, licenses, and instructions.
Do I need Memtest86+ v9.00 specifically?
For DDR5 profile testing, yes, prefer it. The DDR5 bus-stress test arrived in v9.00 on October 15, 2026, and earlier builds do not include it. Older versions still find ordinary cell errors, but they say less about interface instability under an enabled XMP or EXPO profile.
What if Memtest86+ finds errors only at the profile speed?
Then the kit or board cannot hold that profile in your system. Drop one speed grade, retest, and repeat until you find a clean configuration. If errors also appear at default speed, suspect a faulty module, slot, or memory controller, and test sticks one at a time.
Can I run the test with Secure Boot on?
Possibly not. Reportedly, the v9 binaries are signed with the project’s own certificate authority, and Microsoft signing was still pending in October 2026. Disable Secure Boot for the test, then turn it back on. Check the project’s release notes in case that changes.
Does a pass guarantee my RAM is perfect?
No test proves perfection. A clean burn-in with the bus-stress test enabled gives strong evidence that the profile is stable for typical use, but heat, power, and BIOS changes can alter results later. Retest after firmware updates and whenever crashes return.
Should I enable XMP or EXPO?
Match the profile to the platform. Intel boards read XMP and AMD AM5 boards read EXPO. Some kits carry only one of the two, so check the product page before you buy.
Is it safe to leave an overclocked profile enabled?
It is safe once it passes your acceptance run and holds up in real workloads. Keep voltages modest, keep your fallback profile saved, and retest after changes. An unverified profile is the risky one, because silent corruption can damage files long before a visible crash.
