How to find out exactly which RAM your computer takes

To find out which RAM your computer takes, look up the machine or its processor, read what is already installed with a command or two, and buy only modules that match it on six specs. The six are generation, form factor, buffering, ECC, organization (ranks and chip width) and the population rule for the slots you will fill, and the slot itself checks only the generation and whether the module is a DIMM or a SODIMM. A module wrong on either will not go in. A module wrong on any of the others goes in and then fails to boot, runs slower than its label, or runs without the protection you paid for. And if the memory is soldered to the board, which is true of every Apple silicon Mac and most thin laptops, nothing fits, and the same commands tell you so.

Three steps that answer it for most machines

Most people asking this are at a Windows PC or a laptop and want an answer in a few minutes. These three steps give it.

1. Find the machine, or its processor, on this site. The processor fixes the generation, the top speed and the number of channels before the board has any say. For a server, RAM by server has a page for each model, such as the Dell PowerEdge R740, the HPE ProLiant DL380 Gen10 or the Supermicro X11DPi-N. Each states the generation, the slot count and the capacity ceiling, lists the modules that fit with the cheapest per gigabyte first, and prices what it costs to fill every slot. For a laptop or a desktop, look up the processor instead: RAM by processor has a page for each chip, such as the Core i9-14900K or the Ryzen 9 7950X, giving the memory type, speed and channel count it supports, plus family pages such as Intel Core 14th Gen (SODIMM) and AMD Ryzen 7000 Series. On Windows, two lines of PowerShell name both the machine and the chip:

Get-CimInstance Win32_ComputerSystem | Select-Object Manufacturer, Model
Get-CimInstance Win32_Processor      | Select-Object Name

On a Mac, choose About This Mac from the Apple menu, then read the Mac section, because Macs follow their own rules.

2. Read what is installed. On Windows, two lines of PowerShell: the first lists the installed modules, the second counts the slots.

Get-CimInstance Win32_PhysicalMemory | Select-Object DeviceLocator, PartNumber,
  @{n='GB';e={$_.Capacity/1GB}}, SMBIOSMemoryType, FormFactor, TypeDetail,
  ConfiguredClockSpeed, Attributes, DataWidth, TotalWidth
Get-CimInstance Win32_PhysicalMemoryArray | Select-Object MemoryDevices

The first prints one entry per installed module, with the part number, the codes the table below decodes, and the speed the module is running at; MemoryDevices from the second is the socket count. Task Manager, under Performance then Memory, gives a speed, a slots-used count and a form factor, but no part number and no rank. On a Mac, run system_profiler SPMemoryDataType in Terminal; on an Intel Mac with real slots it prints an Upgradeable Memory: line that says whether the memory can be replaced. On Linux, sudo dmidecode -t 16 -t 17 prints the slot count and one block per slot, empty or not.

3. Match the six specs. Decode the output with this table, and buy only modules that agree with it on every row:

If what comes back has no slot to speak of - a Form Factor of Row Of Chips, an LPDDR type, no part number - the memory is almost certainly soldered and nothing fits. An LPCAMM2 machine also reports LPDDR, but on a replaceable module, so the Form Factor decides; the soldered-memory section shows how to tell for certain.

The six specs, and the symptom when one is wrong

The memory controller is inside the processor, not on the motherboard. That has been true of AMD since the Athlon 64 and of Intel since Nehalem, and it is the single fact that explains why the same board has different memory ceilings with different chips in it. So the chain starts at the CPU and runs outward:

Read that table as a fault tree rather than a checklist. The symptom column is diagnostic, because each link fails in a way the others do not. A module that will not physically enter the slot is a generation or form-factor error and nothing else. A module that goes in cleanly and produces no video and no beep is almost always a buffering error, which is why registered and unbuffered memory is the most expensive confusion in second-hand memory. A machine that posts, counts the right total, and runs a speed bin below the label is a population problem, and no amount of buying better modules fixes it.

Four of the six facts are readable from the running machine without opening it. The ceiling and the population table live in documents, and no command on any operating system knows them reliably.

The checklist before you pay

1. Read the six facts off the running machine before you open a single listing, with the commands for your system from the three steps above.
2. Settle buffering from the part number and the label’s buffering suffix, never from Type Detail alone. Consumer firmware writes Synchronous and stops. A module that seats and produces no POST is almost always this mistake, and it is the one that costs a whole purchase.
3. Decide the organization before the capacity. A 32 GB DDR4 module is 2Rx8 on 16 Gbit dies or 2Rx4 on 8 Gbit dies, and the population behavior differs. Filter on /en-us/ddr4/32gb/ and then read the nRxW on each listing, because the capacity facet contains both.
4. Check the population rule before you pay for a speed grade. If you are filling a four-slot board, look up what the platform trains to at two modules per channel and buy that grade. Paying for DDR5-6000 into a configuration that trains at 3600 is money that never reaches the machine.
5. Paste the part number, not a description. “16GB DDR4 laptop RAM” is a category with a fifty-fold price spread in it.
6. Count the chips in the photograph against the label. A label that disagrees with the chip count is a relabeled module.
7. On DDR3, read the voltage as a separate fact. 1.5 V and 1.35 V modules are physically identical and one of them will not run in a low-voltage laptop.
8. Buy the whole population in one go where you can, not because part numbers must match but because a set bought together has the same organization and bins by construction.
9. Sort by price per gigabyte, and buy at a fixed price. Bid-only auction listings are left out of every ranking here by default, because a bid that has not finished rising is not a price; ?bids=show brings them back, marked as bids. All RAM prices ranks the whole catalog on the one number that compares across capacities, and Trends shows how a gigabyte’s price has moved, generation by generation.
10. Test it the night it arrives, while the return window is open: after it arrives has the commands.

Where each fact lands on this site

Swap ddr4 for ddr5, ddr3, ddr2 or ddr as your generation requires, and the same facets exist under each where there is stock to fill them. Everything sorts by price per gigabyte by default, which is the only comparison that survives across capacities: a 32 GB module at twice the price of a 16 GB one is the same deal. For servers, the vendor pages - Dell, HPE, Lenovo and Supermicro - list what each model takes. Those pages are built from vendor documentation, and where a module’s specification cannot be sourced the site records it as not stated rather than inferring it; the methodology page has the detail.

What a listing has to state before it is safe to buy

A listing with the part number and a photograph of the actual label is checkable. Everything else can be derived from those two. The label carries the capacity, the organization, the speed grade, the PC code and the buffering suffix, and the part number resolves the rest. A listing with a stock photograph and a description is the seller’s typing, and the used-memory guide covers what that is worth and what to ask for instead.

Naming the machine exactly

Every vendor lookup takes a model string that the vendor recognizes. Stickers lie, marketing names collide, and the string on the box is frequently not the string in the support database. Get it from firmware. On Windows, three lines give the maker and model, the board, and the BIOS version and serial number:

Get-CimInstance Win32_ComputerSystem | Select-Object Manufacturer, Model
Get-CimInstance Win32_BaseBoard      | Select-Object Manufacturer, Product, Version
Get-CimInstance Win32_BIOS           | Select-Object SerialNumber, SMBIOSBIOSVersion, ReleaseDate

On Linux, read the DMI fields directly:

grep -H . /sys/class/dmi/id/{sys_vendor,product_name,product_version,board_vendor,board_name,bios_version,bios_date}

An example of what comes back from a Lenovo laptop:

/sys/class/dmi/id/sys_vendor:LENOVO
/sys/class/dmi/id/product_name:20XW00ABUS
/sys/class/dmi/id/product_version:ThinkPad T14 Gen 2i
/sys/class/dmi/id/board_vendor:LENOVO
/sys/class/dmi/id/board_name:20XW00ABUS
/sys/class/dmi/id/bios_version:N32ET75W (1.50 )
/sys/class/dmi/id/bios_date:03/15/2023

Read every field, because which one carries the searchable identifier varies by vendor. Lenovo puts a machine type model in product_name and the human name in product_version, and its memory tables are keyed on the machine type model. HP frequently puts a useless four-character board ID in board_name; the string that finds the machine is in product_name. Dell puts the Service Tag in the system serial number, so sudo dmidecode -s system-serial-number hands you the exact input Dell’s support site wants. On Supermicro, board_name is the board model, which is what its memory documentation is organized around.

A server or server board has its own page under RAM by server, such as the Dell PowerEdge R740. A ThinkPad, an OptiPlex or an HP desktop has no page of its own here: look up its processor under RAM by processor, and take the slot count from the vendor’s own memory table, which for Lenovo’s clients is PSREF.

Record the BIOS version and date while you are there. Support for a larger die, and therefore for a larger module, arrives in a BIOS update and not in a new processor, and an old release note is the difference between “this machine cannot take 48 GB modules” and “this machine could not take them in 2022”.

Reading what is installed on Windows

wmic memorychip is gone: WMIC was disabled by default from Windows 11 24H2 and removed outright when Microsoft withdrew the Feature on Demand in August 2026. WMI itself is untouched, so the answer is the CIM cmdlets. The full version of the command from the three steps:

Get-CimInstance Win32_PhysicalMemory | Select-Object DeviceLocator, BankLabel,
  Manufacturer, PartNumber, @{n='GB';e={$_.Capacity/1GB}}, SMBIOSMemoryType,
  FormFactor, TypeDetail, Speed, ConfiguredClockSpeed, Attributes,
  DataWidth, TotalWidth, ConfiguredVoltage

That returns raw integers with no decoding, and Microsoft’s own documentation for the class will actively mislead you on four of them.

Two traps in that table deserve spelling out.

The published TypeDetail value map for the class stops at 4096 and never lists the buffering bits at all, even though bits 13 to 15 are exactly where the SMBIOS specification puts them and exactly what firmware writes. Decode them yourself with a bitwise test:

Get-CimInstance Win32_PhysicalMemory | ForEach-Object {
  $d = $_.TypeDetail
  '{0}  reg={1} unbuf={2} lrdimm={3}' -f $_.DeviceLocator,
    [bool]($d -band 8192), [bool]($d -band 16384), [bool]($d -band 32768)
}

WMI’s FormFactor enumeration is not the SMBIOS one, and the two are offset by a single step. SMBIOS type 17 numbers DIMM as 0x09 and SODIMM as 0x0D; WMI numbers them 8 and 12. Every value above “Other” is one lower in WMI, so a table copied from a SMBIOS reference is wrong by one, and that is where a Windows reading and a Linux one disagree.

For slots and the firmware’s claimed ceiling:

Get-CimInstance Win32_PhysicalMemoryArray |
  Select-Object MemoryDevices, MaxCapacityEx, MemoryErrorCorrection

MemoryDevices is the socket count. MaxCapacityEx is in kilobytes and is the 64-bit field; ignore the deprecated MaxCapacity, a 32-bit field that firmware sets to 0x80000000 when the real value will not fit. MemoryErrorCorrection returns 3 for none, 5 for single-bit ECC and 6 for multi-bit. Any maximum the array claims is firmware’s opinion, for the reasons in the ceiling section.

Task Manager is not enough to buy from. Its speed is the configured one, with no hint of what the module was rated at, and it has no per-slot breakdown: a fine sanity check and a poor specification.

On a Mac, the answer is usually that nothing fits

Choose About This Mac from the Apple menu for the model name, or run system_profiler SPHardwareDataType for the Model Identifier, such as iMac20,1 or MacBookPro18,3. Search that identifier and nothing else: Apple ships several genuinely different machines under one marketing name, and the memory arrangement is one of the things that differs between them. Then read the memory itself:

system_profiler SPMemoryDataType
sysctl hw.memsize

On an Intel Mac with real sockets, SPMemoryDataType prints a block per bank, with Empty where nothing is fitted, plus the Upgradeable Memory: line. On Apple silicon it collapses to little more than a total and an LPDDR type, because the memory is on the SoC package.

Every Apple silicon Mac is soldered, without exception. Among Intel Macs, the machines that take memory are few enough to name:

• The Retina 5K 27-inch iMac has four user-accessible SODIMM slots behind a hatch. Apple’s own specification for the 2020 model reads “8GB (two 4GB) of 2666MHz DDR4 memory; four SO-DIMM slots, user accessible”, configurable to 128 GB: four ordinary DDR4-2666 SODIMMs and nothing proprietary.
• The 2019 Mac Pro takes twelve DDR4 ECC modules, RDIMMs or LRDIMMs but never mixed, on a six-channel Xeon W platform, and LRDIMMs of mixed capacities stop it starting up (Apple Support, “Install and replace memory in your Mac Pro (2019)”, checked October 15, 2026).
• The older Mac Pros. Apple lists the Mid 2010 and Mid 2012 towers as taking 1333 MHz DDR3 ECC UDIMMs or RDIMMs, but not both at once. The Late 2013 model takes 1866 MHz DDR3 ECC, unbuffered or registered but again never mixed, and reaches 64 GB with RDIMMs in all four slots. Apple says a mix of the two gives a memory error tone at power-on (Apple Support, “Mac Pro (Late 2013): Installing or replacing memory”, an archived article, checked October 15, 2026).
• The 2018 Mac mini has two SODIMM slots which Apple documents as serviceable, behind a teardown that is awkward rather than forbidden.

Almost every other Intel Mac from 2013 on is either soldered or requires removing the display to reach the slots, and for those the memory is not an upgrade path.

Soldered memory, LPDDR and CAMM2: when a laptop cannot be upgraded

Soldered memory is the majority case in thin laptops now, and it is the one answer no listing can change. In dmidecode output it has a Form Factor that reads Row Of Chips or Unknown, no part number, and a locator that names a bank rather than a slot. If that is all you have, the machine has no memory upgrade path, and the question becomes the next machine, where how much RAM you need is the thing to settle before you buy. Many thin laptops are half and half, soldered memory plus one socket: the command shows one block for each, the soldered one often with no part number, and the socket is the only upgrade path.

LPDDR is a different standard, not a low-power version of yours. A Type of LPDDR4, LPDDR4X, LPDDR5 or LPDDR5X means a separate JEDEC standard, the JESD209 family, with its own signaling, its own channel width - 16 or 32 bits rather than 64 - and no module form factor at all, because the specification assumes the devices sit directly on the board with trace lengths measured in millimeters. A soldered LPDDR machine has no upgrade path, and the configuration you bought is the configuration you keep. Not “difficult”, not “requires a technician”: the parts are not made in a form that can be fitted. On Windows, SMBIOSMemoryType 30 is LPDDR4 and 35 is LPDDR5, and a script that only tests for the DDR values will report an LPDDR machine as unknown rather than as unupgradeable.

CAMM2 and LPCAMM2 are the exceptions: a flat module compression-attached to the board with screws, carrying a 128-bit bus in one part. JEDEC published the CAMM2 common standard in 2023, and LPCAMM2 is the LPDDR5X version. A machine designed for one takes exactly one, so SODIMMs are not an option and neither is a second module. Check the Form Factor field before assuming either way, because a CAMM2 machine and a soldered one look identical from outside the chassis.

For a laptop that does have SODIMM slots, the modules are in DDR4 laptop memory, DDR5 laptop memory and DDR3 laptop memory, and the rest of this guide applies as it would to a desktop.

Reading what is installed on Linux

sudo dmidecode --type 17 is the complete answer on any machine with a real SMBIOS table, and it prints one block per memory socket whether or not the socket is occupied. An example of a populated block, from a laptop with one 16 GB DDR4-2666 SODIMM fitted:

Memory Device
	Array Handle: 0x0006
	Error Information Handle: Not Provided
	Total Width: 64 bits
	Data Width: 64 bits
	Size: 16 GB
	Form Factor: SODIMM
	Set: None
	Locator: DIMM A
	Bank Locator: BANK 0
	Type: DDR4
	Type Detail: Synchronous Unbuffered (Unregistered)
	Speed: 2667 MT/s
	Manufacturer: Samsung
	Serial Number: 00000000
	Asset Tag: None
	Part Number: M471A2K43CB1-CTD
	Rank: 2
	Configured Memory Speed: 2667 MT/s
	Minimum Voltage: 1.2 V
	Maximum Voltage: 1.2 V
	Configured Voltage: 1.2 V
	Memory Technology: DRAM
	Memory Operating Mode Capability: Volatile memory
	Module Manufacturer ID: Bank 1, Hex 0xCE
	Module Product ID: Unknown

Total Width against Data Width is the ECC test, and it is the only one that does not depend on firmware being honest. Data width is the payload; total width includes whatever extra bits the module carries for error correction:

The 80-bit row surprises people who expected 72: a DDR5 module is two independent 32-bit subchannels, and each carries its own 8 bits of ECC. None of this is the on-die ECC every DDR5 device has, which corrects errors inside the chip, reports nothing to the host and never appears in Total Width; a DDR5 machine without ECC modules is not a machine with ECC. ECC against non-ECC has the full treatment.

Size reads No Module Installed on an empty socket, which is how you count free slots without opening the case.

Speed and Configured Memory Speed answer different questions. Speed is the maximum the module says it supports; Configured Memory Speed is what the controller actually trained to. A module reporting Speed: 3200 MT/s and Configured Memory Speed: 2400 MT/s is being run 25 percent below its label, and there are exactly four reasons: the processor’s own table caps it there, the population rule caps it there, the firmware is running JEDEC defaults instead of the module’s XMP or EXPO profile, or another module in the channel is slower. The configured number is the one you will still be getting after you spend money.

Type Detail is where buffering is supposed to live, and on consumer firmware it is frequently useless, often the single word Synchronous. Server firmware usually fills it in properly as Synchronous Registered (Buffered), Synchronous Unbuffered (Unregistered) or Synchronous LRDIMM. When it is blank, fall back to the part number, because the widths say nothing about buffering: unbuffered ECC DIMMs are a real product category.

Rank is a population constraint, not a performance figure: a channel budgets ranks, not modules, as ranks and 3DS modules explains. The part number is the only field that transfers cleanly to a search. Samsung plus M471A2K43CB1-CTD identifies exactly one product; paste it whole into the part number index and you get the listings for that exact module, as on the M471A2K43CB1-CTD page. For a census of every socket at once:

sudo dmidecode -t 17 |
  grep -E '^[[:space:]]+(Locator|Size|Type|Part Number|Rank|Speed|Configured Memory Speed):'

sudo dmidecode -t 16 adds Number Of Devices, the real slot count, which is more reliable than counting type 17 blocks because some firmware pads them. Its Maximum Capacity is firmware’s opinion, and wrong often enough to be dangerous.

Other commands only look as if they answer the question. lshw prints the example module as 16GiB SODIMM DDR4 Synchronous 2667 MHz (0.4 ns), where the “MHz” is MT/s, repeating the industry’s standard confusion between MHz and MT/s, and /proc/meminfo knows the total and nothing else. Every one of these tools, dmidecode included, reads SMBIOS, which firmware wrote at boot from the module’s SPD chip. To read the SPD itself, load the ee1004 driver on DDR4 and run decode-dimms from i2c-tools; do not sweep the bus with i2cdetect, which on many consumer boards can hang the machine. On Windows, CPU-Z’s SPD tab shows the same data per slot.

Working out what an unlabeled module is

A module with no sticker, or a sticker worn to nothing, is still identifiable. Its capacity is the product of three numbers, two of them countable by eye: devices per rank (64 bits divided by the device width, x4, x8 or x16), die density, and ranks. A 2Rx8 DDR4 module on 8 Gbit dies is 8 devices × 8 Gbit ÷ 8 = 8 GB per rank, 16 GB in all; a 2Rx4 module on the same die has 16 devices per rank and is 32 GB. Same die, same rank count, twice the capacity, which is why server modules are denser than desktop ones, and why an x4 module is not a drop-in for an x8 one on most platforms. The full grid for DDR4:

Read that table backwards to identify a module. A 32 GB DDR4 module is 2Rx8 on 16 Gbit dies, 2Rx4 on 8 Gbit dies, or 4Rx8 on 8 Gbit dies, and those are three different products with three different population behaviors. The capacity on the sticker does not distinguish them. The organization does.

DDR5 works the same way on 32-bit subchannels, two per module, and its 24 Gbit dies give 24 GB single-rank and 48 GB dual-rank modules. 48 GB modules are not a marketing round-up. They are 24 Gbit dies doing exactly what 16 Gbit dies do, and they did not exist when a lot of firmware was written, which is why the ceiling moves with BIOS updates.

Counting chips narrows it to two answers

If you have the module in your hand and no label, count the DRAM packages. Ignore the small chips: the register on an RDIMM, the SPD EEPROM or hub, the thermal sensor, the PMIC on a DDR5 module. Count only the identical large ones.

Chip count gives you devices, not ranks, which is why every row above 9 has two candidates; one SPD read settles it. A count divisible by 9 rather than 8 is a module with check bits, because the ninth device per eight is the ECC device. One physical tell does work: a load-reduced module carries a row of small data buffers along the edge nearest the contacts, nine on a 72-bit DDR4 module and ten on an 80-bit DDR5 one. If you can see that row, the module is an LRDIMM and it will not work in a board expecting RDIMMs.

Reading the label

The organization field, written nRxW, is the JEDEC module labeling convention: 2Rx8 is two ranks of x8 devices, 1Rx16 one rank of x16. It is the single most useful string on the sticker after the part number.

On a DDR2 or DDR3 PC code, and on the 5-digit form sellers write for DDR4 and DDR5 (PC4-21300 is DDR4-2666 written as bandwidth), the letter after the number is the buffering: R registered, E unbuffered with ECC, L load-reduced, none for plain unbuffered. A DDR4 or DDR5 sticker does not work that way: there the module type is the first letter after the next hyphen, so PC4-2400R-UA1 is an unbuffered module whose R only means CL16, and PC4-2666V-RB2 is the registered one. RDIMM, UDIMM and LRDIMM reads a whole label left to right, and the speed guide has the PC-code ladder.

Part numbers are not self-describing, and the field maps circulating for them are reverse-engineered rather than published. Paste the whole number into the part index and check the manufacturer’s datasheet, whose ordering table spells out capacity, organization and speed grade for every suffix; buying used RAM on eBay covers part numbers on listings in more depth.

Form factor, keying, and the DDR4 module that will not go in a DDR5 slot

The generation is physically enforced: pin counts and notch positions differ. The site’s own tables, rendered from the constants the catalog is built on:

Look at the DDR4 and DDR5 DIMM rows. Both are 288 pins on the standard 133.35 mm card. The only thing physically preventing a DDR4 module entering a DDR5 slot is the position of the notch, and JEDEC moved it precisely so that there would be something. Filing the notch would not help, because three things behind those identical pins are each fatal. The protocol is different: command and address encoding, burst length and bank groups all changed, which is also why no adapter exists. The power delivery is inverted: a DDR4 module takes regulated 1.2 V and 2.5 V rails from the board, while a DDR5 module takes a bulk rail and regulates it on the card with its own PMIC, standardized in the JEDEC JESD301 family. And the data organization is different, one 64-bit channel against two 32-bit subchannels. DDR4 and DDR5 SODIMMs differ by two pins, 260 against 262, which is small enough to look like a mistake and is not one.

If a module does not seat with light, even pressure, stop. The latches should close under thumb pressure on the ends. Force tells you the keying is wrong, and the slot is the expensive part: a DIMM socket is soldered to the board and replacing one is a reball-grade repair.

Voltage is a second gate on DDR3, and it catches people

Standard DDR3 runs at 1.5 V. DDR3L is the low-voltage variant at 1.35 V, and it is normally dual-voltage, so it works in an older 1.5 V board. The failure runs the other way. Several platforms - Haswell’s low-power mobile parts are the well-known case - support only 1.35 V, and a 1.5 V-only DDR3 module in one of those will seat perfectly and not work. On DDR3 you have to read the voltage off the label as a separate fact from the generation, and a listing that says “DDR3 1600” without saying 1.5 V or 1.35 V has not told you enough. On DDR3 laptop memory in particular the split is roughly even and the two look identical in a photograph.

Height, heatspreaders and clock drivers

Standard full-height DIMMs are around 30 mm tall. Very low profile modules are roughly 18 mm, and 1U servers, many blade chassis and some small-form-factor desktops need them: a standard-height module seats, works, and stops the lid closing. If the machine is 1U or the manual says VLP, the manual means it. On desktops, tall finned heatspreaders foul large tower coolers, and the clearance figure is published by the cooler maker.

CUDIMM and CSODIMM are DDR5 unbuffered modules carrying a clock driver on the card. They fit the same slots as the plain versions, and a board that does not support the clock driver runs them in bypass at standard speeds, as an ordinary UDIMM. Above DDR5-6400 the clock driver is how the grade is reached at all, so a board without support does not get the speed the module is rated for.

How many modules a channel takes, and at what speed

This is where “it all fits, so why is it slow” gets answered. A memory channel does not budget modules. It budgets chip selects and electrical load. A chip select addresses one rank, and the processor has a fixed number per channel. Electrical load is analog: every module is another stub on a shared line, and more stubs mean a lower rate the link can be trained to, which is why the speed falls when you add modules. Registered, load-reduced and 3DS modules exist to relieve that load; RDIMM against UDIMM against LRDIMM and ranks and 3DS modules have the full treatment. The buying rule from both: choose rank count after you know how many modules the channel will end up carrying. Two dual-rank modules bought with the intention of adding two more later will train lower when the others arrive, and may not train at all.

Two DIMMs per channel at reduced speed is a published table, not a warning

Every platform publishes what it will train to for each population. AMD’s own memory support table for Ryzen 7000 is the clearest example, because it is indexed by module count and by rank, and the rank column turns out to be the one that does nothing:

A Ryzen 9 7950X’s specification page prints it as 2x1R DDR5-5200, 2x2R DDR5-5200, 4x1R DDR5-3600, 4x2R DDR5-3600, counting modules in the board. Module count is the entire table. Fill both slots on a channel and the platform gives up 1,600 MT/s, 31 percent of its rate, whatever is in them. No DDR5 module is sold rated at 3600, so in the four-module case the grade on the sticker is discarded at training time.

Intel derates on the same axis, more gently, and also counts slots on the board, occupied or not: the speed guide carries Intel’s 12th-generation DDR5 table, where an empty second slot per channel costs 400 MT/s. The ARK entry for a Core i9-14900K reads “Up to DDR5 5600 MT/s” and says nothing about two modules per channel; that has to come from the board manual. Servers publish the same kind of table: fourth-generation Xeon Scalable runs DDR5-4800 with one module per channel and DDR5-4400 with two, and server memory capacity limits goes through the server platforms.

Topology decides which slots, not just how many

Almost every four-slot consumer board is wired in a daisy chain, the two slots on a channel in series on the same traces. That is why its manual tells you to populate the second slot from the CPU on each channel, usually labeled A2 and B2. Putting two modules in A1 and B1 leaves an unterminated stub hanging off each channel, and the board will either train lower or fail to train. The rarer T-topology boards behave the opposite way: they are built for four modules and are slower with two than a daisy-chain board is.

Flex mode, and what mismatched capacities actually do

Mismatched module capacities do not disable dual-channel operation. Intel’s Flex Memory Technology, and the equivalent on AMD platforms, interleaves the matched portion and runs the remainder single-channel. Worked on 8 GB in channel A and 4 GB in channel B:

matched portion    4 GB + 4 GB  =  8 GB  interleaved across two channels
remainder          8 GB − 4 GB  =  4 GB  single channel
total                              12 GB usable, all of it

Two thirds of the memory runs at full channel width and one third does not, and both are addressable: better than the folklore of “mismatched memory only runs single channel”, worse than a matched pair. If the choice is between 12 GB in flex mode and 8 GB matched, the answer depends on whether you are running out of memory, and running out of memory is always worse.

Mixing: the rules that matter, and the ones that are folklore

Mixing gets discussed as one question and it is at least six. Separated, with the mechanism for each:

“Identical part numbers” is folklore that costs money on the used market. Nothing in memory training reads a part number. The controller reads each module’s SPD, takes the intersection of the supported bins, checks the rank count against its budget, and trains the channel to the best common configuration. “Faster modules downclock safely” is true at JEDEC bins and false at XMP: enable XMP on a mixed pair and the usual failure is not a refusal to boot but instability under load, which looks like a software problem for a week. So match the absolute rows, match the organization, ignore the brand, and expect JEDEC bins when the modules did not come from one box.

The capacity ceiling, which no command reliably knows

SMBIOS type 16 reports a Maximum Capacity, and it is firmware’s opinion rather than a fact about the hardware. dmidecode’s own documentation warns that DMI table data is frequently inaccurate or simply wrong. A machine reporting 32 GB with 32 GB installed is a common shape of that error, and so is a machine reporting a figure its processor could never address. Treat type 16 as a hint worth checking, never as the answer. The real ceiling is the minimum of four numbers:

Where each vendor publishes, and what each leaves out:

Two things those tables leave out cost the most money. The number moves after the machine ships. ARK now reads 192 GB for the 13th and 14th generation desktop parts, which is four 48 GB modules; the 12th generation entry, on the same LGA1700 socket, still reads 128 GB. An old vendor table is stale rather than wrong, and the BIOS release notes are the only place that records when support for a new die arrived. And the processor supporting something is necessary and not sufficient: the ARK entry for a consumer Core i9 says ECC is supported, but ordinary consumer chipsets never wire it up, and ECC needs the controller, the chipset, the firmware and the module, all four. For servers, server memory capacity limits works the ceiling through platform by platform.

Why the machine shows less memory than you installed

Install 16 GB and the operating system reports something under it. That is normal, and the size of the gap says what is happening. The physical address space below 4 GiB has to accommodate more than memory: PCIe devices’ registers and frame buffers, firmware’s reserved regions and, with integrated graphics, a display aperture. Modern firmware re-presents the memory those regions shadow above the 4 GiB line, a setting usually called memory remap or above-4G decoding, and it needs a 64-bit operating system. A machine showing 3.2 GB of 4 GB installed either has remapping off or is running a 32-bit operating system. Integrated graphics also takes a real allocation, which Windows reports in Task Manager as hardware reserved. What to expect:

installed, from dmidecode -t 17     16 GB  = 16,384 MiB
firmware and device reservations    roughly 100 to 400 MiB on a typical desktop
MemTotal in /proc/meminfo           about 15.6 to 16.0 GiB

A gap of a few hundred megabytes is firmware doing its job. A gap of gigabytes is a setting, a 32-bit operating system, or integrated graphics with a large aperture. And ECC costs no capacity: a 16 GB ECC module gives the operating system 16 GB, because the check bits live on extra DRAM devices, which is why the module is 72 bits wide and carries nine packages rather than eight.

QVL lists, and what they are worth

A qualified vendor list is a validation list, not an exclusion list. Supermicro’s wording says what all of them mean: modules are listed as a convenience, with no representation as to compatibility and no obligation to support anything on or off the list. Off-list memory usually works. A QVL lists kits rather than modules, so two modules with a kit’s part number from two sellers is not the configuration that was validated. It is bound to a firmware revision, usually an old one, so absence from a two-year-old QVL is evidence of when the list was written, not of what the board will take. What a QVL is good for is narrowing: read the organizations and capacities listed and you learn whether the board takes x4 or x8, whether it takes 3DS, and the largest module anyone has got working.

Vendor-branded server modules from HPE, Dell and Lenovo are ordinary JEDEC modules with a vendor sticker and, in some generations, vendor data in the SPD. They work in other machines, and third-party modules generally work in theirs. What varies by generation is whether the management firmware logs a message about it, and the machine’s own documentation is the place to check.

The older generations, where most of the second-hand stock is

A machine from 2008 has better memory options today than it had when it was new, and they cost almost nothing, but three traps live in DDR, DDR2 and DDR3.

FB-DIMM is the DDR4-against-DDR5 trap, one generation earlier. Fully Buffered DIMMs were a mid-2000s server product built on DDR2 devices, with the same 240-pin count as an ordinary DDR2 DIMM, the notch in a different position, and an Advanced Memory Buffer on the card. Neither fits the other’s board, and neither will seat. The machines that take them are a narrow set of 2006 to 2009 Intel server and workstation chipsets, including the first-generation Mac Pro.

DDR3 voltage is the second, covered in the DDR3 voltage section.

Registered memory reaches further back than people expect. Registered DDR2 and even registered DDR modules exist in volume, do not work in a desktop board, and are priced as though nobody wants them, which makes them the cheapest memory on the market for an old two-socket workstation that takes them; DDR3 registered memory and the DDR2 and DDR catalogs are where it sits.

Two machines, worked end to end

The laptop. sudo dmidecode -t 16 -t 17 returns a two-socket array with one socket populated: Size: 16 GB, Form Factor: SODIMM, Type: DDR4, Total Width: 64 bits, Data Width: 64 bits, Rank: 2, Part Number: M471A2K43CB1-CTD, Speed: 2667 MT/s, Configured Memory Speed: 2667 MT/s, and one socket reading Size: No Module Installed. On Windows the same module reads SMBIOSMemoryType 26, FormFactor 12, Attributes 2, DataWidth 64 and TotalWidth 64, with MemoryDevices 2 on the array.

That is DDR4, SODIMM, non-ECC (64 equals 64), unbuffered (a consumer laptop SODIMM is unbuffered by construction), 16 GB dual rank, which the grid says is x8 on 8 Gbit dies, and one free slot with nothing derated. A second module should be a DDR4 SODIMM, unbuffered, ideally the same 16 GB 2Rx8 so that flex mode is not involved, and need not share the part number. Go to DDR4 laptop memory, filter to 16 GB, and read 2Rx8 on the listings.

The server. The same commands return twelve sockets in one array, six populated, each reading Size: 32 GB, Form Factor: DIMM, Type: DDR4, Total Width: 72 bits, Data Width: 64 bits, Type Detail: Synchronous Registered (Buffered), Rank: 2, Speed: 2666 MT/s, Configured Memory Speed: 2666 MT/s. That is DDR4, full-height DIMM, registered, ECC from the 72-against-64 gap, dual rank at 32 GB (2Rx4 on 8 Gbit dies or 2Rx8 on 16 Gbit dies), and six of twelve slots free.

The free slots decide the purchase. Twelve slots on a six-channel processor is two slots per channel, so the machine is at one module per channel and running the platform’s top bin. Filling the other six adds a real 192 GB and, on most DDR4 server platforms, costs a bin across the whole machine; replacing the six with 64 GB modules keeps the speed and costs more per gigabyte. Neither answer is correct in general, but the question is answerable from dmidecode and appears nowhere on a listing. If the installed modules are 2Rx4, the new ones need to be as well, because many server boards will not mix x4 and x8 in a channel. DDR4 registered memory and the machine’s own page under RAM by server are where that resolves.

After it arrives, while the return window is open

Run the same commands again and check that every slot you filled reports a module, that Size and Part Number match the listing, and that Configured Memory Speed is not below Speed. If it is, work through the four causes in order: the processor’s table, the population rule, a disabled XMP or EXPO profile, and a slower module in the same channel. The third cause is the common one, and it is why a DDR5-6000 kit boots at 4800: 4800 is a JEDEC bin and 6000 is a profile the firmware has not been told to apply, so the module is not faulty and the seller did not lie.

If the machine powers on, resets and does it again after a memory change, do not assume a dead module. Firmware trains the memory at boot and caches the result; a stale or corrupt cache produces exactly that loop, and clearing the firmware configuration discards it so the next boot trains from scratch. MHz against MT/s covers profiles and training.

If the machine is meant to run ECC, confirm that it is running rather than merely fitted. On Linux:

sudo ras-mc-ctl --summary
ls /sys/devices/system/edac/mc/
cat /sys/devices/system/edac/mc/mc0/dimm*/dimm_edac_mode
dmesg | grep -i -E 'edac|ecc'

dimm_edac_mode reading SECDED or a stronger mode is the proof; an empty /sys/devices/system/edac/mc/ on a platform that should have one means ECC is not enabled in firmware. On Windows, MemoryErrorCorrection of 5 or 6 is the platform’s claim, and ECC activity shows as WHEA-Logger entries in the System event log. No counters means no ECC, whatever the module says on the label.

Then test the memory. One full pass is the minimum and an overnight run is better:

memtest86+            the GPL tester, UEFI capable, current versions know DDR5
MemTest86             the PassMark one, also UEFI, broader hardware reporting
memtest=4             a Linux boot parameter, early-boot only, limited passes
memtester             userspace, tests only what it can allocate

The first two are the real tests, because they run with no operating system holding memory. A repeatable error is a failed module. A single error that never comes back is the socket, most often a module not quite seated. Reseat it and run again, then move it to a different slot and run again: an error that follows the module is a return, one that stays with the slot is a slot, and one that does not recur was the seat.

What cannot be known from outside the machine

• SMBIOS Maximum Capacity is firmware’s opinion and is frequently wrong, in both directions.
• Whether a specific board will train a specific population at a specific speed is not published. Per-processor tables and per-board QVLs are not statements about your four modules in your slots.
• The die inside a module is not fixed by its part number in every case. Manufacturers revise which die a part number uses, which is why two modules with the same number can behave differently.
• An XMP or EXPO profile is a claim about one kit on one reference platform, not a specification the module has to meet in your machine.
• The SPD’s end-user region is writable, so a determined seller can make a module report anything to every tool here.

That is the case for the effort. A registered ECC module from a decommissioned server has no wear mechanism and no moving parts, and it sells for a fraction of a desktop module of the same capacity because most buyers cannot use it. The discount is not a risk premium. It is a compatibility premium, and it is payable in exactly the six facts this guide is about.