Tools
Guides
On this page

August 18, 2026

How to check CPU, RAM, and disk model and capacity on Windows — GUI and command line

“So what’s actually in this machine?” is a question with a dozen answers on Windows, and they are not all equally good. The box says 16 GB; Task Manager says 15.8. The laptop’s spec sheet claims an SSD; the one installed is a slower model than the marketing line. The RAM you want to upgrade — is it DDR4 or DDR5, and how many slots are free? None of these questions is answerable from the outside of the case, and opening it is exactly what Windows’ inventory interfaces exist to prevent.

The good news is that every fact you need is exposed somewhere. The less good news: the interfaces are layered by era. There are the GUI tools (Task Manager, msinfo32, Device Manager, Settings), there is wmic — the command-line inventory of record for twenty years, now deprecated on current Windows 11 builds — and there is PowerShell’s CIM layer, the modern replacement that every Windows 7 machine and later already has. This guide walks all three layers, from the thirty-second GUI look to the exact commands that read per-stick RAM part numbers and disk SMART health, and closes with when third-party tools earn their install.

The GUI path: three tools, three altitudes#

Task Manager’s Performance page: the quickest accurate read#

Ctrl+Shift+Esc → Performance tab. This is the fastest place to get all three answers at once, and on Windows 10/11 it is more detailed than people expect:

  • CPU: the top of the page shows the exact marketing model — Intel(R) Core(TM) i7-12700H, AMD Ryzen 7 7840HS — plus, in the smaller lines, base clock, sockets, cores, and logical processors. The distinction between cores and logical processors is visible right here: an 8-core/16-thread CPU shows Cores: 8, Logical processors: 16. The right edge also shows live clock and utilization, which turns this page into a quick sanity check that the machine is actually boosting.
  • Memory: total in use and the total installed, plus — the detail people miss — Speed (e.g. 3200 MHz), Slots used (2 of 4 or 1 of 2 — the single most useful fact before buying an upgrade), and Form factor. This is where the difference between “16 GB installed” and “one 16 GB stick in a two-slot machine” becomes visible, which decides whether your next upgrade is another stick or a replacement.
  • Disk: each volume’s page is named after the physical disk’s model — Samsung SSD 970 EVO Plus 1TB — with capacity, and the live activity graph. On Windows 11 the disk pages also surface whether the volume is bitlocker-encrypted and, for NVMe drives, the temperature.

Task Manager’s weakness is scope: it shows one disk per page, does not enumerate all physical disks if several are present, and shows no health data. It answers “what is in here” well and “is it healthy” not at all.

System Information (msinfo32): the exhaustive single page#

Win+R → msinfo32. One window, everything: BIOS version and date, motherboard model under BaseBoard Product, exact processor name and count, RAM (though only the total — this is Task Manager’s mirror image: broad but shallow on memory), and a full component tree on the left for display, audio, network, and storage. Its killer feature is System Summary → Components → Storage → Drives/Disks, which lists every physical disk with model and size — including ones Task Manager’s per-volume pages make you hunt for.

msinfo32 also solves the “document this machine” problem: File → Save produces a complete NFO-format snapshot, which is why support engineers asking “send me an msinfo32” are asking for exactly this export.

Device Manager: per-device driver-level detail#

Win+X → Device Manager. Not the first tool for capacity questions, but the right one for the layer beneath: Disk drives lists each physical disk by model name; expanding one and checking Properties → Details → Hardware Ids gives you the VEN/DEV identifiers that pin down the exact controller. Processors lists one entry per logical processor, which confuses people (“why does my 6-core show 12 CPUs?”) — it is topology, not inventory. Device Manager is also where you check whether a device has a driver problem, which is a different question from whether it exists.

Settings → System → About: the basics#

Settings → System → About shows processor model, installed RAM, device name, and Windows edition/build. Adequate for a quick model check, redundant once you know msinfo32. Its one unique value: the build number and feature-update version of Windows itself, which you need when deciding which command-line layer (below) your machine supports.

Settings → Storage: the built-in SMART view#

Windows 10 (later builds) and 11 surface disk health in the GUI: Settings → System → Storage → Advanced storage settings → Disk & volumes. Select a physical disk and you get a Drive health field — Healthy, Unhealthy, or with prediction failures flagged — plus estimated remaining life percentage on NVMe drives that report it. This is genuine SMART data, read through Windows’ storage stack, presented without any third-party tool. It is coarse (no attribute tables, no per-sensor readings), but as a zero-effort check it answers “is this drive about to die” well enough to know when to escalate to CrystalDiskInfo.

The command line: works on every version#

The GUI is for looking; the command line is for precision, repeatability, and remote machines. Two families exist, and knowing which to use on which Windows is half the practical knowledge.

wmic: the veteran, now deprecated — but still everywhere#

The Windows Management Instrumentation console, wmic, reads the same SMBIOS/WMI data the GUIs do, one query per line. It works on everything from Windows XP through current Windows 11 (with a caveat below). The four queries that matter:

wmic cpu get name,numberofcores,numberoflogicalprocessors

Exact CPU model plus the cores/threads split — the answer to “which i7 is this, and is it 4-core or 8-core”.

wmic memorychip get banklabel,capacity,speed,manufacturer,partnumber

This is the single most useful inventory command on Windows. memorychip returns one row per physical stick: which bank it sits in, capacity in bytes (multiply by 0.000000000931 to get GB, or read 16777216000 as ~16 GB), the configured speed, and — the part everyone forgets exists — the manufacturer and part number. With that string you can buy the identical module, or check the vendor’s datasheet for its rated timings. This is how you answer “can I mix this with another stick” with facts instead of forum folklore.

wmic diskdrive get model,size,mediatype
wmic baseboard get manufacturer,product

Disk models with capacities (bytes again — divide by 10^9 for the marketing-GB figure) and the motherboard identity, which is what you need before a BIOS update or a RAM compatibility check against the board’s QVL.

The caveat: wmic is deprecated. Current Windows 11 builds ship it as a deprecated feature-on-demand, and on some fresh installs the bare wmic command errors. Microsoft’s guidance is unambiguous — move to PowerShell CIM. But wmic remains the right answer on locked-down machines, in old batch scripts, and on Windows 7/8 where the PowerShell alternatives behave inconsistently (see FAQ).

PowerShell CIM: the modern layer (Windows 7 and later)#

The same data through a cleaner interface, with real objects you can sort, filter, and convert:

Get-CimInstance Win32_Processor | Select-Object Name,NumberOfCores,NumberOfLogicalProcessors,MaxClockSpeed

Get-CimInstance Win32_PhysicalMemory | Select-Object BankLabel,Capacity,Speed,Manufacturer,PartNumber,SMBIOSMemoryType

Win32_PhysicalMemory is wmic memorychip’s counterpart — one object per stick, with capacity already in bytes you can format. SMBIOSMemoryType is the raw DDR-generation code (its reading is covered in the FAQ, because it is how you answer DDR3-versus-DDR4 without opening the case).

Get-CimInstance Win32_DiskDrive | Select-Object Model,Size,InterfaceType,MediaType

Physical disks by model. Size is bytes; wrap the pipeline with a calculated property if you want it readable:

Get-CimInstance Win32_DiskDrive |
  Select-Object Model, InterfaceType,
    @{n='SizeGB';e={[math]::Round($_.Size/1GB,1)}}

That [math]::Round($_.Size/1GB,1) pattern — divide by the 1GB constant, round — is worth memorizing; it converts every byte-valued property in this article at once.

For volumes rather than physical disks:

Get-Volume | Sort-Object DriveLetter |
  Select-Object DriveLetter,FileSystemLabel,FileSystem,
    @{n='SizeGB';e={[math]::Round($_.Size/1GB,1)}},
    @{n='FreeGB';e={[math]::Round($_.SizeRemaining/1GB,1)}}

And for the era-correct disk query, Get-PhysicalDisk (Windows 8.1+) pulls from the Storage management layer rather than SMBIOS, which means it includes health status — see the next section.

One historical note: on older systems you will see Get-WmiObject used interchangeably with Get-CimInstance. They read the same classes; Get-CimInstance is the newer, cleaner cmdlet (serializes dates properly, works over WS-Management remoting) and there is no reason to prefer the old one on any current script. If you maintain scripts that must run on Windows 7, Get-WmiObject is the safer bet of the two there.

systeminfo: the total-RAM one-liner#

systeminfo

A few seconds of gathering, then a full text report: OS build, boot time, and the Total Physical Memory line in MB. It answers exactly one hardware question (installed RAM total), but it does so on every Windows since forever, needs no elevation, and the same output includes hotfixes and network config — which is why it remains the universal “first command on an unfamiliar box”.

dxdiag: the GPU and VRAM answer#

Win+R → dxdiag, or dxdiag.exe. The Display tab shows the GPU model (e.g. NVIDIA GeForce RTX 4060), its driver version and date, and — the number people come for — Display Memory (VRAM), alongside Dedicated and Shared memory figures. The System tab additionally lists CPU model and memory total, and Save All Information exports the whole thing to a text file: the standard artifact when filing GPU bug reports. Note the distinction dxdiag draws between dedicated VRAM and shared memory: the shared figure is system RAM the GPU can borrow, and it is why “8 GB graphics” on a laptop with shared memory is not the same claim as 8 GB on a discrete card.

Disk detail: model, SSD-versus-HDD, and health#

Disks deserve their own section because “which disk” has three layers — physical disk, partition, volume — and because they are the component that fails.

Get-PhysicalDisk | Format-Table FriendlyName,MediaType,BusType,Size,HealthStatus

This one command answers the questions people actually have:

  • FriendlyName — the model string (WD Blue SN580 1TB, CT1000MX500SSD1).
  • MediaType — SSD or HDD. This is the authoritative SSD/HDD answer, read from the device’s own reporting rather than guessed from speed. (A handful of early SSDs misreport as HDD; on those, BusType being NVMe or SATA-SSD is the giveaway.)
  • HealthStatus — Healthy, Warning, or Unhealthy, aggregated from SMART predictive-failure data. Warning on any disk you care about means: back up today, not this weekend.
  • BusType — NVMe versus SATA, which tells you the upgrade path’s ceiling before you shop.

Below the physical disk, the two layer commands:

Get-Partition | Format-Table DiskNumber,PartitionNumber,DriveLetter,Type,Size
Get-Disk | Format-Table Number,FriendlyName,PartitionStyle,Size

PartitionStyle (GPT versus MBR) rides along free and matters before any boot-mode change. And for SMART specifically, the hardware truth lives in Get-StorageReliabilityCounter:

Get-PhysicalDisk | Get-StorageReliabilityCounter |
  Select-Object DeviceId,Temperature,Wear,ReadErrorsTotal,PowerOnHours

Wear is the consumed-life percentage on SSDs; PowerOnHours tells you whether that “lightly used” secondhand drive is telling the truth. Support for these counters varies by drive firmware, but on name-brand NVMe drives they are populated and they are the closest thing to CrystalDiskInfo’s attribute table that ships in the box.

When to go third-party#

The built-in layer covers identity and coarse health. Three tools cover the rest — named here so you know what to search for:

  • CrystalDiskInfo — the SMART reader. Full attribute tables (reallocated sectors, pending sectors, CRC errors), per-attribute raw values with explanations, temperature logging, and drive-firmware-level detail the Windows stack does not surface. Install it the moment HealthStatus says anything other than Healthy, or before trusting any secondhand drive.
  • CPU-Z — the CPU/memory motherboard deep-dive: live per-core clocks and voltages, SPD readout per RAM slot (the full JEDEC timing table, not just current speed), exact memory controller info, and the motherboard/BIOS identifiers. Win32_Processor tells you what the CPU is; CPU-Z tells you what it is doing right now — which is why overclockers and memory-tuning people live in it.
  • HWiNFO — the sensor forest: every temperature, fan, voltage, and power rail the motherboard exposes, logged over time. The tool for “why does this machine thermal-throttle under load”, because it correlates clocks with temperatures second by second.

The division of labor is clean: Windows’ built-in tools for what is installed and is it healthy; these three for how is it behaving and why.

FAQ#

What is the relationship between wmic and PowerShell’s CIM cmdlets?#

They are two doors into the same room. The room is WMI — Windows Management Instrumentation, the infrastructure that exposes system inventory and state as classes (Win32_Processor, Win32_PhysicalMemory, Win32_DiskDrive). wmic is the old command-line client for that infrastructure; Get-CimInstance is the modern PowerShell client (CIM — Common Information Model — being the standard WMI implements). Same classes, same data, different front doors. wmic cpu and Get-CimInstance Win32_Processor read the identical SMBIOS tables the BIOS filled in at boot. The deprecation affects only the old front door: the classes themselves, and the CIM layer, are the supported future. Practical rule: write anything new in PowerShell; keep wmic for machines or scripts where PowerShell is unavailable or unwanted.

Why does Task Manager show less RAM than the sticker says?#

Because some of it never became Windows memory. The two usual reasons: hardware reserved — memory claimed by firmware and devices before Windows boots (BIOS shadowing, integrated peripherals); and integrated graphics sharing — an iGPU without its own VRAM carves a block out of system RAM (512 MB to several GB, configurable in BIOS). A 16 GB laptop showing 15.8 GB usable has ~200 MB reserved; one showing 15.0 GB with an iGPU has 1 GB shared to graphics. You can see the reserved amount in Task Manager’s memory page (“Hardware reserved” in the bottom-right breakdown). It is normal, it is not a defect, and the only lever is the BIOS setting for the graphics share — where trading RAM against iGPU headroom is a real tradeoff, not a free lunch. (A stick seated in the wrong slot, or one dead stick, shows up differently: capacity simply missing from the Slots-used count — which is exactly why you cross-check Task Manager’s Slots used against memorychip’s row count.)

How do I tell whether my RAM is DDR3 or DDR4?#

Read the SMBIOS generation field. In PowerShell:

Get-CimInstance Win32_PhysicalMemory |
  Select-Object BankLabel,Speed,SMBIOSMemoryType,ConfiguredClockSpeed

SMBIOSMemoryType is a numeric code where the DDR generations cluster: 24 = DDR3, 26 = DDR4, 34 = DDR5 (the field has no friendly names — it is the raw SMBIOS memory-type byte, which is why forum posts full of mystery numbers exist). Two caveats make the speed fields worth reading alongside it. First, older wmic memorychip get memorytype returned a different enumeration that lumps all modern DDR together (the value 0), so trust SMBIOSMemoryType specifically. Second, Speed is the stick’s rated maximum while ConfiguredClockSpeed is what it is actually running at — DDR4-3200 sticks in a machine that clocks them at 2400 show both numbers diverging, which is how you detect “the BIOS never enabled XMP” without opening anything. As a tiebreaker when you distrust the codes: DDR3 tops out at 2133 MT/s rated, DDR4 starts at 2133, and DDR5 starts at 4800 — overlapping only at exactly 2133, so the speed field alone resolves nearly every real machine.

Closing thoughts#

The layers stack cleanly once you see the pattern: GUI for a glance, wmic for the past twenty years of muscle memory, PowerShell CIM for everything you write down. The queries that pay for the time spent learning them are memorychip/Win32_PhysicalMemory — one row per stick, with the part number that makes upgrade shopping exact — and Get-PhysicalDisk with its MediaType and HealthStatus, the two-word answer to “which drive is it and is it dying”. Keep those two in your notes and the rest of this guide becomes optional: identity, capacity, generation, and health, each one command away on any Windows machine from 7 to 11.

← All guides