Knowing how to check RAM speed is easy. Reading the number correctly is the hard part. Windows, CPU-Z, BIOS screens, Linux and macOS all report memory speed in slightly different units, and one stick can show 3000, 4800 or 6000 depending on where you look. DDR5 modules are sold in MT/s, so a DDR5-8000 stick such as TeamGroup’s recently unveiled 128GB CQDIMM is rated for 8,000 megatransfers per second while its physical clock sits near 4,000 MHz. A tool that prints 4,000 is not lying, it is showing the other half of the same fact.
This tutorial walks through 13 steps that check RAM speed on Windows 11, Linux and macOS as of October 26, 2026. Windows 11 version 26H2, the 2026 Update, reached general availability on October 21, 2026, and every Windows step below works on it. You will confirm what your kit is rated for, what it actually runs at, and whether a gap between the two points to a missing XMP or EXPO profile, a single-channel layout, or just a unit mix-up. Plan for about 30 minutes. Every tool is free, and you will finish with a small Python auditor that logs the result on a schedule.
Memory speed belongs in the same routine as your other health checks. If a PC feels slow in games or compiles, pair this guide with our walkthrough on how to check CPU temperature and you will rule out the two most common silent causes in one sitting: a processor that throttles and memory that never reached its rated speed.
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 RAM Speed Numbers Actually Mean: MT/s vs MHz
DDR stands for double data rate. The memory moves data on both the rising and the falling edge of its clock, so the number of transfers per second is twice the clock frequency. A kit marketed as DDR5-6000 performs 6,000 million transfers per second (6,000 MT/s) from a clock near 3,000 MHz. Retail boxes, BIOS menus and Windows Task Manager usually print the transfer rate. CPU-Z prints the real clock. Both are correct, and neither is the other’s typo.
The confusion gets worse because marketing still says MHz on many product pages. Plenty of forum posts claim a DDR5-6000 kit is running at half speed when CPU-Z shows 3000. It is not. The rule that saves you from this mistake: if a tool shows a value near 3,000 for a DDR5-6000 kit, the tool shows the clock. If it shows 6000, the tool shows the transfer rate. Never double a value that already reads in the thousands of MT/s.
The standard behind all of this is the JEDEC DDR5 specification, published as JESD79-5. JEDEC defines the base speeds every module must support at power-on. Anything faster, such as DDR5-6000 on a consumer kit, is a vendor profile stored on the module (Intel XMP or AMD EXPO) that your motherboard must load deliberately. That is why a brand-new PC often boots with fast memory running at a slow default. The kit is fine, the profile is simply switched off.
| Module label | Transfer rate (MT/s) | Clock CPU-Z shows (MHz, approx.) | Peak, one channel (GB/s) | Peak, dual channel (GB/s) |
|---|---|---|---|---|
| DDR4-3200 | 3,200 | 1,600 | 25.6 | 51.2 |
| DDR5-4800 | 4,800 | 2,400 | 38.4 | 76.8 |
| DDR5-5600 | 5,600 | 2,800 | 44.8 | 89.6 |
| DDR5-6000 | 6,000 | 3,000 | 48.0 | 96.0 |
| DDR5-6400 | 6,400 | 3,200 | 51.2 | 102.4 |
| DDR5-8000 | 8,000 | 4,000 | 64.0 | 128.0 |
The bandwidth columns are plain arithmetic: transfer rate times 8 bytes per 64-bit channel. They are theoretical ceilings, and no real program reaches them. Use them as a yardstick. If a dual-channel DDR5-6000 system measures close to the 48 GB/s single-channel figure instead of the 96 GB/s ceiling, you have found a layout problem rather than a speed-rating problem. We come back to that in the diagnosis section.
Prerequisites and Tool Versions for This RAM Speed Check
You need very little. Each tool below reads the same underlying firmware tables (SMBIOS) or the module’s SPD chip, so the choice depends on your operating system and how deep you want to go. Install nothing you do not need. On Windows 11 the first three steps use only built-in features.
- Windows 11: any supported build, including version 26H2. PowerShell 5.1 ships with Windows, PowerShell 7.x also works.
- CPU-Z from CPUID: freeware for Windows. According to CPUID’s version history, 3.01 (released August 20, 2026) is the newest standard x86/x64 release, and a separate CPU-Z ARM64 build (1.06, announced October 6, 2026) covers Windows on ARM. CPUID does not list native Linux or macOS builds.
- Linux:
dmidecodefrom your distribution’s repository. Current distributions package the 3.6 and 3.7 series. You needsudorights. Optional extras arei2c-toolsfor SPD decoding andsysbenchfor a bandwidth probe. - macOS: the built-in Terminal and
system_profiler. No installs. - Python 3.10 or newer: only for the final project. NumPy is optional and adds a quick bandwidth probe.
- Administrator or root access: required for the firmware table reads on Linux and for the BIOS steps on every platform.
Before you begin, close anything that eats memory, because heavy background load does not change the rated speed but it will distort the bandwidth test in Step 10. If you run virtual machines or emulators, shut them down first. Android emulators in particular reserve large blocks of RAM, as our breakdown of what affects Android emulator performance on Windows 11 explains.
| Where you read it | Platform | Shows rated speed | Shows running speed | Unit you will see |
|---|---|---|---|---|
| Task Manager, Memory page | Windows 11 | No | Yes | MT/s |
| PowerShell Win32_PhysicalMemory | Windows 11 | Yes (Speed) | Yes (ConfiguredClockSpeed) | Usually MT/s |
| CPU-Z Memory tab | Windows | No | Yes | MHz (real clock) |
| CPU-Z SPD tab | Windows | Yes, with profile tables | No | MHz and MT/s |
| UEFI/BIOS memory page | Any PC | Yes | Yes | MT/s or MHz, varies by vendor |
| dmidecode -t memory | Linux | Yes (Speed) | Yes (Configured Memory Speed) | MT/s on current versions |
| system_profiler SPMemoryDataType | macOS | Intel Macs only | Intel Macs only | MHz |
Phase 1: Quick Windows Checks (Steps 1 to 3)
Start with the checks that need no download. They answer the question most readers actually have: is my memory running at the speed I paid for? Do these three steps in order, because Step 1 gives you the target number that Steps 2 and 3 compare against.
Step 1: Find Your Kit’s Rated Speed and Layout
Write down three facts before you measure anything. First, the rated speed on the box, invoice or the sticker on the module, for example DDR5-6000. Second, how many sticks you installed and in which slots. Third, the maximum memory speed your processor officially supports, which you can find on the maker’s product page for your CPU. Many CPUs list a lower official figure than the kit’s profile, and the profile is then treated as an overclock. That detail matters in Step 11.
If you threw the box away, the part number is stored on the module. The next step prints it. Paste that part number into the memory maker’s website and you will get the rated speed, voltage and timings in seconds.
Step 2: Read Task Manager’s Memory Page
Press Ctrl+Shift+Esc, open the Performance tab and click Memory. The right-hand panel lists Speed, Slots used, Form factor and Hardware reserved. On Windows 11 the Speed line reports in MT/s, so a DDR5-6000 kit that is running correctly reads 6000 MT/s. A kit sitting on the JEDEC default reads a much lower figure such as 4800 MT/s.
Memory
32.0 GB DDR5
Speed: 6000 MT/s
Slots used: 2 of 4
Form factor: DIMM
Hardware reserved: 312 MBThe sample above is an illustrative healthy dual-stick setup. Two details deserve a second look. Slots used tells you how many modules Windows sees, which exposes a stick that is not seated properly. And Task Manager shows only the running speed, never the rated one, so a kit that is stuck at 4800 MT/s looks perfectly normal here unless you already know it should say 6000. Microsoft keeps tuning Task Manager too. Its October 13, 2026 release notes for Windows 11 describe wider process grouping, which makes the memory-hungry apps on the Processes page easier to read.
Step 3: Pull Rated and Running Speed From PowerShell
PowerShell reads the SMBIOS memory records and returns both numbers side by side, which is what Task Manager cannot do. Open Windows Terminal and run the command below. Microsoft deprecated the old WMIC tool and recent Windows 11 builds no longer install it by default, so use the CIM cmdlet instead of the wmic memorychip commands you may find in older guides.
Get-CimInstance Win32_PhysicalMemory |
Select-Object BankLabel, Manufacturer, PartNumber,
@{n='GB';e={[int]($_.Capacity/1GB)}},
Speed, ConfiguredClockSpeed, SMBIOSMemoryType |
Format-Table -AutoSizeBankLabel Manufacturer PartNumber GB Speed ConfiguredClockSpeed SMBIOSMemoryType
--------- ------------ ---------- -- ----- -------------------- ----------------
BANK 0 Corsair CMK32GX5M2B6000C30 16 6000 4800 34
BANK 2 Corsair CMK32GX5M2B6000C30 16 6000 4800 34Read this illustrative sample like a detective. Speed is the module’s rated value (6000). ConfiguredClockSpeed is what the board negotiated at boot (4800). The column header says clock, but on modern firmware both fields report MT/s. SMBIOSMemoryType 34 means DDR5, and 26 means DDR4. In this example the kit runs 1,200 MT/s below its rating, which is the classic signature of a profile that was never enabled. If both numbers match, your memory is running at its rated speed and you can skip ahead to the verification steps.
Phase 2: Confirm Everything With CPU-Z (Steps 4 and 5)
The built-in tools tell you what Windows believes, and they are the fastest answer to how to check RAM speed without installing anything. CPU-Z reads the hardware directly and shows the memory controller’s actual clock, the channel layout and the timings. It also opens the module’s SPD chip, which lists every profile the stick supports. Those two views together settle almost every argument about whether a kit is running correctly.
Step 4: Install CPU-Z and Read the Memory Tab
Download CPU-Z only from CPUID’s own site. The tool is freeware, so any page that asks for money or wraps the file in a download manager is a third-party reseller you should skip. Choose the ZIP edition if you prefer a portable copy or the installer if you plan to keep it. On a Windows on ARM laptop pick the ARM64 build instead, since the standard x86/x64 download is the wrong one for that hardware.
Launch the program, wait a few seconds while it scans, and click the Memory tab. Focus on four fields: Type, Size, Channel # and DRAM Frequency. The remaining boxes list timings, and you only need those when you tune performance later.
General
Type DDR5
Size 32 GBytes
Channel # 4 x 32-bit
DC Mode Symmetric
Timings
DRAM Frequency 3000.0 MHz
CAS# Latency (CL) 30.0 clocksThis illustrative output belongs to a dual-DIMM DDR5-6000 setup that runs correctly. The DRAM Frequency of 3000 MHz is the real clock, so multiply by two to get 6000 MT/s. DDR5 splits every DIMM into two 32-bit sub-channels, which is why a healthy two-stick kit appears as 4 x 32-bit instead of the dual label older DDR4 systems showed. If CPU-Z lists only 2 x 32-bit with two sticks installed, the board is running a single DIMM’s worth of width and you will fix that in Step 12. For reference, CPU-Z has validated 2394 MHz clocks as roughly 4788 MT/s, which shows the same double-the-clock rule in a real submission.
Step 5: Compare Against the SPD Tab
Open the SPD tab and use the Memory Slot Selection drop-down to inspect each module. The tab prints the manufacturer, part number, module size and a Max Bandwidth line such as DDR5-6000 (3000 MHz). Below that sits a timings table with several columns. The JEDEC columns list the standard fallback speeds. The XMP or EXPO column lists the vendor profile the manufacturer certified for that kit.
Now compare the two tabs. If the Memory tab shows 2400 MHz while the SPD tab advertises a 3000 MHz profile, you have proof that the stick can run faster than the board is allowing. If both slots show the same part number and capacity, you have a matched pair, which gives the memory controller its easiest job. If the sticks differ, expect the board to drop to the slowest common setting, a pitfall we cover below.
- Match found: Memory tab clock equals the SPD profile clock. Nothing to fix.
- Profile gap: Memory tab shows a JEDEC speed while the SPD tab offers a faster profile. Enable it in the BIOS (Step 6).
- One module missing: the SPD slot list shows fewer modules than you installed. Reseat the stick.
- Different modules: two part numbers or two capacities. Expect the lowest common speed.
Phase 3: Check the Setting in UEFI/BIOS (Step 6)
The firmware is the source of truth for what speed the board requested at boot. Checking it takes two minutes and also shows whether the profile switch exists at all. Every operating-system tool you used so far merely reports the result of what the firmware decided.
Step 6: Open the Memory Page and Load the Profile
Reboot and press the board’s setup key during the logo screen, usually Delete or F2. On Windows 11 you can also open Settings, go to System, then Recovery, choose Advanced startup and select UEFI Firmware Settings. Once inside, switch to the advanced view and look for an overclocking or memory page, whose name depends on the brand.
Look for a single drop-down that lists profile names. Intel boards call the vendor profile XMP, AMD boards call it EXPO, and older AMD boards may label the same switch DOCP. Choose Profile 1 first. Many kits ship a second profile with different timings or a lower voltage, but Profile 1 is the one the manufacturer advertises on the box. Press F10, confirm the save and let the machine restart.
Expect the first boot after this change to take longer than normal. The board retrains memory at the new speed and the screen can stay black for a minute or more. Do not hold the power button during this phase. If the machine reboots three times and falls back to defaults, that means the profile failed training, and the troubleshooting section lists the usual fixes. When the desktop appears, go back to Step 2 or Step 3 and confirm that the running speed changed.
Phase 4: How to Check RAM Speed on Linux (Steps 7 and 8)
Linux reads memory details from the same SMBIOS tables Windows uses, but it exposes them through the command line. That makes it easy to script, which matters for the project at the end. If you are still choosing between systems, our Windows vs Linux 2026 comparison looks at how each handles RAM under load.
Step 7: Run dmidecode to List Every Module
Install the package if it is missing, then query the memory device records. The dmidecode manual page documents the type filter, and a practical install and usage guide for dmidecode covers the distro-specific package names. The commands work the same on Ubuntu, Debian, Fedora and Arch. They also work on Linux Mint, which our Linux Mint vs Ubuntu comparison shows is built on the Ubuntu base.
sudo apt install dmidecode
sudo dmidecode -t memory | grep -E "Locator:|Size:|Type:|Speed:|Part Number:" Size: 16 GB
Locator: DIMMA1
Type: DDR5
Speed: 6000 MT/s
Part Number: CMK32GX5M2B6000C30
Configured Memory Speed: 4800 MT/s
Size: 16 GB
Locator: DIMMB1
Type: DDR5
Speed: 6000 MT/s
Part Number: CMK32GX5M2B6000C30
Configured Memory Speed: 4800 MT/sSpeed is the module’s rated value and Configured Memory Speed is what the board negotiated, exactly like the two PowerShell columns in Step 3. Empty slots show up as No Module Installed, and the grep above filters them out because they carry no speed. Older dmidecode versions label the second field Configured Clock Speed and may print MHz where current ones print MT/s, so check the unit before you compare numbers. Notice also that Linux gives you the slot names (DIMMA1, DIMMB1), which tells you whether you filled the recommended pair of slots.
Step 8: Cross-Check With lshw and SPD Decoding
One tool can be wrong, so ask a second. The lshw utility reads the same tables but formats them differently, and decode-dimms from the i2c-tools package reads the SPD chip itself rather than the firmware’s summary. The second source matters because it catches boards that report a stale configuration.
sudo lshw -class memory -short
sudo apt install i2c-tools
sudo modprobe ee1004
sudo decode-dimms | head -40
free -h
lscpu | grep -i "model name"The ee1004 module exposes DDR4 SPD data and recent kernels use a separate spd5118 driver for DDR5, so load whichever matches your memory generation. If decode-dimms prints nothing, your board may block SPD access, which is common on laptops and some OEM desktops. That is harmless. The dmidecode result from Step 7 is already enough to answer the main question. Running these commands inside a virtual machine or container only shows virtual hardware, so run them on the host.
Phase 5: How to Check RAM Speed on a Mac (Step 9)
Macs split into two worlds. Intel Macs use normal socketed or soldered DIMMs and report a speed per module. Apple silicon Macs place the memory in the processor package, so the speed is fixed by the chip and cannot be changed or upgraded. If you are weighing a Mac purchase against a PC, our macOS vs Windows 2026 comparison covers the wider trade-offs.
Step 9: Query system_profiler on macOS
system_profiler SPMemoryDataType
sysctl hw.memsizeMemory:
Memory: 32 GB
Type: LPDDR5
Manufacturer: HynixThe sample shows the Apple silicon layout. You get the total size, the memory family and the manufacturer, but no per-module speed line, because the unified memory is part of the chip design and Apple publishes no user-adjustable setting for it. On an Intel Mac the same command prints one block per DIMM with a Speed field in MHz and a Status field, which is what you want for comparing against the rating. The second command returns the total memory in bytes, useful for scripts. Because macOS gives you no rated-versus-running pair, the useful check on a Mac is simply that the full capacity is visible and that Memory Pressure in Activity Monitor stays green during your normal workload.
Phase 6: Measure, Interpret and Fix (Steps 10 to 12)
A label can say 6000 MT/s while the machine moves data like a single-channel budget build. The last three diagnostic steps close that gap. First you measure real throughput, then you interpret it against the rated figure and your CPU’s limits, and finally you fix whatever the numbers expose.
Step 10: Run a Quick Bandwidth Probe
Close browsers, games and virtual machines before you test. On Linux, sysbench gives a clean read with one command. On Windows or macOS, a few lines of Python with NumPy do the same job and also feed the project in Step 13. Neither test produces a number you should compare with a review site, because thread counts, caches and background work all move the result. The value lies in comparing the same machine before and after a change, such as enabling a profile.
sudo apt install sysbench
sysbench memory --memory-block-size=1M --memory-total-size=20G --threads=4 runpython3 -m pip install numpy
python3 - <<'EOF'
import time
import numpy as np
src = np.ones(32 * 1024 * 1024, dtype=np.float64)
dst = np.empty_like(src)
best = 0.0
for _ in range(5):
start = time.perf_counter()
np.copyto(dst, src)
elapsed = time.perf_counter() - start
best = max(best, 2 * src.nbytes / elapsed / 1e9)
print(f"best copy throughput: {best:.1f} GB/s")
EOFThe Python probe copies a 256 MiB array, counts both the read and the write, and keeps the best of five runs. It runs on a single thread, so it will land well under the multi-channel ceilings in the first table. That is fine. Record the number, enable the profile, run the probe again and watch it climb. On Windows PowerShell replace the heredoc by saving the Python lines in a file named probe.py and running it with python probe.py.
Step 11: Compare Rated Speed Against Your CPU’s Official Limit
Now line up three numbers: the rated speed from Step 1, the running speed from Steps 2 to 9 and the official memory speed for your processor. Processor makers publish the supported memory speed on each product page. For instance, AMD’s desktop lineup page lists the Ryzen 9 9950X3D as its newest Ryzen 9 X3D desktop part, and the spec table on a page like that names the memory types and speeds the company validated. A kit whose profile exceeds that official figure still works on most boards, but you are technically running an overclock, and stability depends on the individual CPU and board.
This is also the moment to compute latency, because speed alone hides it. True first-word latency in nanoseconds equals the CAS latency divided by the real clock in GHz. A DDR5-6000 kit at CL30 runs a 3.0 GHz clock, so 30 divided by 3.0 gives 10 ns. A higher CL number on faster memory is therefore not automatically worse, so compare the calculated nanoseconds rather than the CL value alone. CPU-Z’s Memory tab gives you the CL value you need.
Step 12: Fix the Mismatch
Work through the fixes in order of cost, cheapest first. Most gaps disappear at the first or second item.
- Load the profile. Enable XMP, EXPO or the board’s equivalent in the BIOS (Step 6) and confirm with Step 2.
- Check slot placement. With two sticks on a four-slot board, the manual normally names the two slots that give you dual channel. Using the wrong pair leaves one channel idle.
- Reseat the modules. Power off, unplug, press each stick until both clips click, and boot again.
- Update the BIOS. Memory compatibility lists and training code improve with firmware releases. Note that a BIOS update usually resets your profile to defaults, so repeat item 1 afterward.
- Lower the target. If the full profile fails, try a slower profile, or set the speed manually one step down. A stable 5600 MT/s beats a flaky 6000 MT/s.
- Match your modules. Replace mixed sticks with a single matched kit.
After each change, return to Step 3 or Step 7 and confirm the configured speed moved. More guides on the surrounding hardware tasks live in our hardware section, including firmware recovery and stress-testing walkthroughs.
Reading Your Results: What Each Pattern Means
After the earlier steps you will hold a handful of numbers. This table maps the most common combinations to a cause and a next action, so you do not have to guess. Match your pattern in the left column, then follow the right column.
| What you see | What it means | Next action |
|---|---|---|
| Running speed equals rated speed, CPU-Z clock is half the rated MT/s | Healthy. CPU-Z shows the real clock | Nothing to fix |
| Running speed far below rated, SPD tab lists a faster profile | XMP/EXPO profile is switched off | Enable Profile 1 in the BIOS (Step 6) |
| Running speed matches rated, bandwidth probe sits near single-channel level | Sticks share one channel or the board runs a single DIMM’s width | Move sticks to the slot pair named in the manual |
| Slots used shows fewer modules than installed | A stick is not seated or has failed | Reseat each stick alone, then together |
| Four sticks installed, speed lower than a two-stick setup | Four-DIMM loads often cap the stable speed | Use two larger sticks or lower the target speed |
| Two different part numbers listed | Mixed kit, board runs the lowest common settings | Replace with one matched kit |
| Rated speed reads 0 or blank | Virtual machine, container or limited OEM firmware | Check on the host or use CPU-Z’s SPD tab |
Keep the table nearby when you audit several machines. In practice, the profile gap and the slot-placement problem account for most of the cases you will meet. The rest tend to involve mixed kits, four-stick builds and laptops where the speed is fixed at the factory.
Common Pitfalls When You Check RAM Speed
These six mistakes produce most of the panicked forum threads. Each one has a quick check that clears it up.
- Doubling a number that is already doubled. Task Manager and most BIOS screens print MT/s. Only CPU-Z prints the real clock. If you see 6000 and multiply by two, you will think you own 12,000 MT/s memory.
- Trusting the box instead of the system. The rated speed is a ceiling. Without a loaded profile the machine runs a slower JEDEC speed, and Task Manager will say so.
- Reading Hardware reserved as missing RAM. Task Manager subtracts memory that firmware and integrated graphics claim, so a 32 GB kit never shows a full 32 GB as usable.
- Following old WMIC guides. Commands such as wmic memorychip fail on recent Windows 11 builds because WMIC is deprecated. Use Get-CimInstance.
- Downloading CPU-Z from a mirror. Stick to CPUID’s own site. Third-party download pages sometimes bundle extras, and the tool is freeware, so a mirror that asks for payment is a red flag.
- Judging a single tool. A tool can show a stale or virtualized value. Cross-check with a second source, ideally one that reads SPD directly.
A seventh habit helps too. Run your checks before and after any BIOS update, because firmware changes silently reset memory settings more often than people expect. A thirty-second note in a text file saves an hour of confusion later.
Troubleshooting: 10 Problems and Their Fixes
When a step fails or a number looks wrong, find the matching symptom below.
- Task Manager shows 4800 MT/s but the kit is rated for 6000. The profile is off. Enable XMP or EXPO in the BIOS and recheck.
- CPU-Z shows 3000 MHz for a DDR5-6000 kit. That is correct. The value is the real clock, and the transfer rate is twice that.
- PowerShell prints blank or zero speeds. You are probably inside a virtual machine, or the OEM firmware leaves the fields empty. Run the command on the host, or read the SPD tab in CPU-Z.
- Only one module appears. Power off, reseat both sticks, and test each stick alone in the first slot. If one stick never shows up, it or its slot is faulty.
- The PC will not boot after enabling a profile. Wait several minutes for memory training. If it loops three times, the board usually falls back to defaults. Clear the CMOS, boot at default speed, and retry with a lower profile or an updated BIOS.
- The speed reverted after a BIOS update. Updates reset memory settings. Load the profile again.
- Four sticks run slower than two. Four-DIMM loads strain the memory controller, and boards often cap stable speed lower. Use two higher-capacity sticks if you can.
- dmidecode says command not found or permission denied. Install the package, run it with sudo, and on some distributions call it by its full path,
/usr/sbin/dmidecode. - decode-dimms prints nothing. Load the right SPD driver (ee1004 for DDR4 or spd5118 for DDR5) or accept that your board hides the bus. dmidecode already answers the speed question.
- The laptop shows a low speed and the BIOS has no memory page. Most thin laptops solder LPDDR memory with a fixed speed and ship no profile menu. Nothing is wrong, and nothing can be changed.
If a machine crashes or throws blue screens after you raise the speed, the profile may be unstable on your particular CPU and board. Run a full memory test such as Memtest86+ for several passes, drop one speed grade, and test again. Do not keep running a configuration that fails memory testing, because corrupted memory can damage files without any warning.
Advanced Tips for Power Users and Fleet Admins
Once the basics work, a few extra habits turn a one-off check into a proper routine.
- Watch latency, not just speed. Use the nanosecond formula from Step 11 when you compare kits. Two kits with the same MT/s can differ by several nanoseconds.
- Keep the controller ratio in mind. At high speeds, many memory controllers switch to a ratio mode that lowers the controller clock relative to the memory clock. Past that point extra MT/s may not help latency, so check your board manual before chasing the last 400 MT/s.
- Spot ECC modules. In dmidecode output, a Total Width larger than the Data Width (72 bits versus 64 bits) signals ECC memory, common in workstations and servers.
- Know the server roadmap. Industry reporting from April 2026 describes MRDIMM Gen2 designs targeting 12,800 MT/s and Gen3 in early development at 17,600 MT/s. These are roadmap targets for servers, not consumer parts you can buy today.
- Log after every change. The project below appends a CSV row each run, which makes before-and-after comparisons painless.
- Audit Linux gaming rigs too. If you run Windows games through Lutris on Linux, a profile that silently reset to 4800 MT/s can cost frames, and the dmidecode check takes five seconds.
- Scale it out. For a small office, push the Python script with your management tool and collect the CSV files centrally.
Beyond that, treat memory like any other consumable setting. Check it after BIOS updates, after hardware swaps and whenever performance feels off.
Step 13: Complete Working Project, a Cross-Platform RAM Speed Auditor
The last step packages everything into one script. It runs on Windows, Linux and macOS, reads each module’s rated and configured speed with the same methods you used by hand, measures a quick copy bandwidth, flags problems and appends the result to a CSV file in your home folder. Save it as ram_audit.py.
#!/usr/bin/env python3
"""ram_audit.py: compare rated vs configured RAM speed and log the result."""
import csv
import datetime
import json
import platform
import re
import subprocess
import time
from pathlib import Path
LOG = Path.home() / "ram_speed_log.csv"
TOLERANCE = 0.95
def run(cmd):
try:
return subprocess.run(cmd, capture_output=True, text=True, timeout=60).stdout
except (OSError, subprocess.SubprocessError):
return ""
def first_int(text):
m = re.search(r"(\d+)", str(text or ""))
return int(m.group(1)) if m else 0
def windows_modules():
ps = ("Get-CimInstance Win32_PhysicalMemory | "
"Select-Object BankLabel,PartNumber,Capacity,Speed,ConfiguredClockSpeed | "
"ConvertTo-Json")
raw = run(["powershell", "-NoProfile", "-Command", ps]).strip()
if not raw:
return []
data = json.loads(raw)
if isinstance(data, dict):
data = [data]
return [{
"slot": d.get("BankLabel") or "?",
"part": (d.get("PartNumber") or "").strip(),
"gb": round(int(d.get("Capacity") or 0) / 2**30),
"rated": int(d.get("Speed") or 0),
"configured": int(d.get("ConfiguredClockSpeed") or 0),
} for d in data]
def linux_modules():
out = run(["sudo", "-n", "dmidecode", "-t", "memory"])
modules = []
for block in out.split("\n\n"):
if "Memory Device" not in block or "No Module Installed" in block:
continue
def field(name):
m = re.search(r"^\s*" + name + r":\s*(.+)$", block, re.M)
return m.group(1).strip() if m else ""
size = field("Size")
gb = first_int(size)
if "MB" in size:
gb = max(1, gb // 1024)
configured = field("Configured Memory Speed") or field("Configured Clock Speed")
modules.append({
"slot": field("Locator") or "?",
"part": field("Part Number"),
"gb": gb,
"rated": first_int(field("Speed")),
"configured": first_int(configured),
})
return modules
def mac_modules():
raw = run(["system_profiler", "-json", "SPMemoryDataType"])
try:
items = json.loads(raw)["SPMemoryDataType"]
except (ValueError, KeyError):
return []
modules = []
for item in items:
for sub in item.get("_items") or [item]:
speed = first_int(sub.get("dimm_speed"))
modules.append({
"slot": sub.get("_name", "unified"),
"part": sub.get("dimm_part_number") or sub.get("dimm_type", ""),
"gb": first_int(sub.get("SPMemoryDataType") or sub.get("dimm_size")),
"rated": speed,
"configured": speed,
})
return modules
def bandwidth_gbs():
try:
import numpy as np
except ImportError:
return None
src = np.ones(32 * 1024 * 1024, dtype=np.float64)
dst = np.empty_like(src)
best = 0.0
for _ in range(5):
start = time.perf_counter()
np.copyto(dst, src)
elapsed = time.perf_counter() - start
best = max(best, 2 * src.nbytes / elapsed / 1e9)
return round(best, 1)
def verdict(modules):
if not modules:
return "NO_DATA"
notes = []
for m in modules:
if m["rated"] and m["configured"] and m["configured"] < m["rated"] * TOLERANCE:
notes.append("BELOW_RATED")
break
if len({m["part"] for m in modules}) > 1:
notes.append("MIXED_MODULES")
if len(modules) == 1:
notes.append("SINGLE_MODULE")
return ",".join(notes) or "OK"
def main():
system = platform.system()
reader = {"Windows": windows_modules, "Linux": linux_modules,
"Darwin": mac_modules}.get(system)
modules = reader() if reader else []
row = {
"time": datetime.datetime.now().isoformat(timespec="seconds"),
"host": platform.node(),
"os": system,
"modules": len(modules),
"total_gb": sum(m["gb"] for m in modules),
"rated_mts": max((m["rated"] for m in modules), default=0),
"running_mts": min((m["configured"] for m in modules), default=0),
"copy_gbs": bandwidth_gbs(),
"verdict": verdict(modules),
}
new_file = not LOG.exists()
with LOG.open("a", newline="") as fh:
writer = csv.DictWriter(fh, fieldnames=list(row))
if new_file:
writer.writeheader()
writer.writerow(row)
print(json.dumps({"summary": row, "modules": modules}, indent=2))
if __name__ == "__main__":
main()Run it with python ram_audit.py on Windows or macOS. On Linux, add a sudoers rule that lets your user run dmidecode without a password prompt, because the script calls sudo -n and will otherwise return no data. Here is the sample output from the broken state in the earlier examples (illustrative values):
{
"summary": {
"time": "2026-10-26T10:05:12",
"host": "DESKTOP-BUILD01",
"os": "Windows",
"modules": 2,
"total_gb": 32,
"rated_mts": 6000,
"running_mts": 4800,
"copy_gbs": 28.4,
"verdict": "BELOW_RATED"
},
"modules": [ ... ]
}The verdict field uses four flags: OK, BELOW_RATED (configured speed under the rated speed), MIXED_MODULES (more than one part number) and SINGLE_MODULE. NO_DATA appears when the script cannot read the firmware tables, as in a locked-down virtual machine. Mac modules may not report a per-module speed on Apple silicon, and the script treats that as unknown rather than as a fault.
# Windows: run daily at 09:00
schtasks /Create /SC DAILY /TN RamAudit /TR "python C:\tools\ram_audit.py" /ST 09:00
# Linux: allow passwordless dmidecode, then add a cron job
echo "youruser ALL=(root) NOPASSWD: /usr/sbin/dmidecode" | sudo tee /etc/sudoers.d/ram-audit
sudo chmod 440 /etc/sudoers.d/ram-audit
( crontab -l 2>/dev/null ; echo "0 9 * * * /usr/bin/python3 /opt/tools/ram_audit.py" ) | crontab -With the scheduler in place, you get a dated record of every change. After a BIOS update, open the CSV and check whether the running speed dropped. After you enable a profile, check that the bandwidth column rose. That log answers the question this whole tutorial started with, and it shows how to check RAM speed on a schedule without anyone opening a settings screen.
FAQ: Checking RAM Speed
How do I check RAM speed on Windows 11 in under a minute?
Press Ctrl+Shift+Esc, open Performance, then Memory. The Speed line shows the running speed in MT/s. For the rated speed next to it, run the Get-CimInstance Win32_PhysicalMemory command from Step 3 in PowerShell.
Why does CPU-Z show half the speed printed on my RAM?
CPU-Z shows the real memory clock, while the label shows the transfer rate. DDR memory moves data twice per clock cycle, so DDR5-6000 appears as roughly 3000 MHz. The kit is running normally.
Why is my DDR5 running at 4800 instead of 6000?
The most likely reason is that no XMP or EXPO profile is enabled, so the board uses a standard JEDEC speed. Enter the BIOS, load Profile 1 and reboot. Four-stick builds and mixed kits can also hold the speed down.
Is it safe to enable XMP or EXPO?
The module maker certifies these profiles for its own kits, and enabling one is a normal setup step. Your CPU and board must support the speed, though. If the profile exceeds the processor’s official memory spec, treat it as a mild overclock and test stability before you rely on it.
Can I check RAM speed on a Mac?
Yes, with system_profiler SPMemoryDataType in Terminal. Intel Macs list a speed per module. Apple silicon Macs list the memory type and size but no module speed, because the memory sits inside the chip package.
Is CPU-Z free and safe to use?
CPUID distributes CPU-Z as freeware for Windows. Download it only from CPUID’s own site and ignore pages that ask for payment. It reads hardware information and changes nothing on the system.
Does faster RAM always improve performance?
No. Gains depend on the workload, the CPU and the channel layout. Processor-bound games and memory-heavy workstation tasks tend to respond, while many everyday tasks barely change. Fixing a disabled profile or an idle channel is worth doing, and chasing the last speed grade usually is not.
