bsd-hardware.info

You can check nearly every major hardware component on a Linux system—CPU, memory, storage, GPU, network adapters, and motherboard—using built-in commands and system files, without installing anything. The practical goal is to identify exact model numbers, capacities, and the driver in use, then compare them against a hardware database such as the Linux Hardware Database (linux-hardware.org) to judge Linux compatibility. This guide covers what to check, how to retrieve it, and how to read the results.

The hardware categories worth checking

Focus on six areas. Each answers a different question about the machine.

Retrieving details with built-in commands

CPU

lscpu

Expected output includes architecture, CPU model name, core and thread counts, and cache sizes. For per-core flags and vendor, read /proc/cpuinfo. The model name string is what you match against a database entry.

Memory

free -h
sudo dmidecode -t memory

free -h gives usable total. dmidecode reports each slot: size, type (DDR4/DDR5), speed, and manufacturer. If dmidecode shows empty slots or a lower total than expected, that is a detection or seating issue, not a Linux limitation.

Storage

lsblk -o NAME,MODEL,SIZE,TRAN
sudo smartctl -i /dev/nvme0

lsblk shows device names, models, capacity, and transport (SATA, NVMe, USB). smartctl (from smartmontools) adds firmware and interface details. The model string is the key for compatibility lookups.

GPU and network

lspci -k

The -k flag is the important part: it lists the kernel driver in use for each device. A GPU or Wi-Fi adapter with no driver line, or with Kernel driver in use: nouveau where you expected a proprietary driver, tells you immediately where a problem lies.

Motherboard and firmware

sudo dmidecode -t baseboard
sudo dmidecode -t bios

These give vendor, board model, and BIOS/UEFI version—useful when a database entry depends on firmware level.

Reading the details correctly

Three fields carry most of the diagnostic weight:

• Model number — the exact string, not a marketing name. "Intel Wi-Fi 6 AX200" is matchable; "Intel wireless" is not.
• Driver in use — confirms the kernel recognized the device and loaded a module. Missing driver is the most common cause of "hardware not working."
• Capacity and speed — compare reported values against the spec sheet. A RAM stick reporting half its rated speed often means a slot or BIOS setting issue.

Comparing against a hardware database

The Linux Hardware Database (linux-hardware.org) is a high-detail database of computer hardware with reported Linux compatibility. The workflow:

1. Collect the model strings from the commands above.
2. Search the database for the device or the full machine (laptop/desktop model).
3. Compare reported driver, kernel version, and compatibility status against your system.
4. If your device is absent, submitting a probe adds data for the next user.

Use the database to answer "will this work before I buy" and "why doesn't mine work" with the same evidence.

When missing details signal a problem

Incomplete output is itself information:

• Device listed but no driver — kernel module missing or unsupported; check dmesg for errors.
• RAM slots empty or underreported — reseat modules or check BIOS memory mapping.
• Storage model blank — controller in a compatibility mode; check BIOS SATA/NVMe settings.
• GPU shows a fallback driver — expected for some cards; confirm whether the intended driver is installed.

Cross-check any anomaly in the hardware database before assuming a fault—sometimes the "missing" detail is normal for that chipset.

Computer hardware is the set of physical parts you can touch inside and around a computer: the processor, motherboard, memory, storage, graphics card, power supply, case, and the peripherals connected to them. Software is the instructions; hardware is what executes them. This explainer covers the core components, how they connect and depend on each other, the line between internal parts and peripherals, and why compatibility matters when you build or upgrade. It applies to desktops and laptops running any operating system, though the Linux Hardware Database at linux-hardware.org is a useful reference when you want to check whether specific parts are known to work under Linux.

The core internal components

A computer is a set of parts that pass data and power between each other. Each has one main job:

CPU and motherboard

The CPU sits in a socket on the motherboard, and the two must match: the socket type, chipset, and firmware support determine which processors a board accepts. The motherboard also carries the RAM slots, expansion slots, storage ports, and the connections for power and front-panel buttons. In practice, the motherboard is the part that decides what else you can install.

RAM and storage

RAM is volatile: it holds the data of programs currently running and is cleared when power is removed. Storage is non-volatile: it keeps the operating system, applications, and files. More RAM helps when many programs run at once; faster or larger storage mainly affects how quickly things load and save. RAM must match the motherboard's supported type and generation, while storage must match an available port (SATA or M.2/NVMe).

GPU, PSU, and case

The GPU handles graphics output and can be a separate card in a PCIe slot or integrated into the CPU. A discrete card adds its own power draw and physical size, which brings in the PSU and case. The PSU must supply enough power with the right connectors, and the case must fit the board size, card length, and cooler height while providing airflow. These three are where build mistakes most often show up: a card that does not fit, a PSU without the needed cable, or a case with poor ventilation.

How the parts depend on each other

No component works alone. The CPU needs the motherboard for its socket and power, the motherboard needs RAM and storage to be useful, the GPU needs a slot and power, and everything needs the PSU and a case to sit in. A single mismatch can stop a build: a CPU that does not fit the socket, RAM of the wrong generation, a card too long for the case, or a PSU too weak for the load. This interdependence is why compatibility checks matter more than any single part's specifications.

Internal parts vs. peripherals

Internal components live inside the case and are required for the computer to run. Peripherals are external devices connected through ports: keyboard, mouse, monitor, printer, webcam, and external drives. They are input/output devices — they let you send commands and receive results — but the computer can boot and run without most of them. The distinction is practical: when something fails, internal parts usually prevent startup or cause instability, while a peripheral problem usually affects only one function.

Why hardware compatibility matters

When building or upgrading, check compatibility before buying. The key questions are: does the CPU fit the motherboard socket and firmware, does the RAM match the board's supported type, does the storage match an available port, does the GPU fit the case and have PSU power, and does the PSU have enough capacity and the right connectors? For Linux users, one more check helps: whether the specific part is known to work with the kernel and drivers. The Linux Hardware Database (linux-hardware.org) records detailed hardware information and compatibility reports, so you can look up a laptop, desktop, or individual component before committing. Treat it as a reference point, not a guarantee — a part listed as working is evidence, not a promise for every configuration.

A quick way to reason about any PC

Ask three questions about any machine: what parts does it contain, how are they connected, and do they match? Identify the CPU socket and motherboard chipset, the RAM type and amount, the storage interface, the GPU and its power needs, and the PSU capacity. If those line up, the hardware is coherent. If you are upgrading, change one part at a time and verify the matching parts still fit — that habit prevents most build and upgrade problems.

BSD is a family of Unix-like operating systems—most notably FreeBSD, OpenBSD, and NetBSD—that share a common heritage and a development model in which the kernel and core userland tools are designed and released together. It differs from Linux mainly in that structure, in its permissive licensing, and in how hardware support is organized. BSD is a reasonable choice if you want a coherent, conservatively engineered system for a server, a network appliance, or a security-focused machine; it is a less obvious choice if you depend on very new consumer hardware or on software that assumes Linux-specific interfaces.

What "BSD" actually refers to

BSD is not one operating system. The name covers several independent projects, each with its own release cycle, installer, and priorities:

All of them descend from the Berkeley Software Distribution of Unix, and all ship a complete base system: kernel, C library, shell utilities, and often a compiler and server daemons, maintained as one unit.

How BSD differs from Linux

Kernel and userland are developed together

On a Linux system, the kernel comes from one project and the userland tools usually come from GNU, BusyBox, or another provider, assembled by a distribution. BSD projects develop the kernel and the base userland in a single source tree and release them together. The practical effect is that a base install is internally consistent, and upgrading the system means upgrading the whole base rather than tracking kernel and userland versions separately.

Licensing

BSD operating systems use permissive licenses (the BSD family of licenses, plus others depending on component). Linux uses the GPL for the kernel. The difference matters mostly if you plan to redistribute modified code: permissive licensing places fewer conditions on derivative works. For an end user running the system, licensing rarely changes day-to-day behavior.

Hardware support model

Linux hardware support often arrives through vendor-contributed drivers in the kernel tree. BSD projects maintain their own driver trees, so support for a given chipset or laptop model can lag, and some devices are supported on one BSD and not another. This is the single most important practical check before committing to BSD on a specific machine: verify that your storage controller, network adapter, graphics chip, and Wi-Fi card are supported by the version you intend to run.

Package management and third-party software

Each BSD has its own approach. FreeBSD offers the pkg package manager with prebuilt binary packages, plus the Ports Collection for building from source with local options. OpenBSD uses its own package tools and releases packages in step with the OS version. Software that is written for Linux—especially anything relying on Linux-specific kernel interfaces—may need a compatibility layer or may not run at all. Check the project's package repository for the applications you actually need before deciding.

Where BSD is commonly used

• Servers and hosting: FreeBSD is a long-standing choice for web and file servers, partly because of its networking stack and the integrated base system.
• Networking appliances: OpenBSD's default security posture and its firewall and routing tools make it a frequent pick for firewalls, VPN endpoints, and routers.
• Security-sensitive systems: OpenBSD's audit practices and default hardening are the reason many people choose it.
• Older or unusual hardware: NetBSD's portability means it can run on architectures that other systems have dropped.
• Desktops: possible and used by experienced users, but this is where the hardware-support gap is felt most, particularly with recent laptops, Wi-Fi, and graphics.

Practical considerations for newcomers

1. Check hardware compatibility first. Look up your exact machine or components in the hardware notes for the specific BSD release you plan to install. Community-maintained hardware databases and the project's own supported-hardware lists are the places to start.
2. Confirm your applications exist. Search the package repository for each tool you rely on. Browsers, office suites, and development toolchains are generally available; niche or Linux-only software may not be.
3. Expect to read documentation. The handbooks published by FreeBSD and OpenBSD are thorough and are the primary reference for installation and configuration. Community forums are smaller than Linux's, so self-sufficiency helps.
4. Plan the install around the base system. Because the base is managed as a unit, learn the project's upgrade procedure before you need it, rather than treating it like a Linux distribution's package upgrade.

Deciding between BSD and Linux

Choose BSD when a consistent, conservatively maintained base system, permissive licensing, or a specific project's strengths (OpenBSD's security defaults, FreeBSD's server tooling, NetBSD's portability) match your goal, and when your hardware and software are known to be supported.

Choose Linux when you need the widest hardware coverage, the largest software ecosystem, or vendor support for a particular device or application. For a first desktop install on a recent laptop, Linux is usually the lower-friction path; BSD becomes attractive once you have verified that your specific components are supported and you value the integrated design.

Choose a desktop if you want the most performance per dollar, easy upgrades, and don't need to move your computer. Choose a laptop if portability matters more than raw power and future upgradability. If a desktop is right for you, the next decision is prebuilt vs custom build: prebuilt if you want to start using it immediately with a single warranty, custom if you want specific parts, better value at higher budgets, and a clear upgrade path. Newegg sells both ready-made computers and millions of individual PC parts, so all three paths are available from one storefront.

Desktop vs laptop: the core trade-offs

The practical rule: if you game or run heavy workloads at a desk more than 80% of the time, a desktop gives you more machine for the same money. If you need to work or play away from that desk regularly, a laptop is the only option that actually fits the use case.

Prebuilt desktop vs custom build

Once you've picked a desktop, decide how it gets assembled.

Choose a prebuilt if:

• You want to unbox and start using it the same day
• You want one warranty and one point of contact for support
• You're buying at a lower budget, where prebuilts often undercut DIY once you count the OS and peripherals
• You don't want to troubleshoot compatibility, BIOS, or cable management

Choose a custom build if:

• You have specific requirements (a particular GPU, a quiet-focused case, a workstation CPU, ECC memory)
• You plan to upgrade over time and want standard, replaceable parts
• You're comfortable diagnosing a no-boot system with basic steps like reseating RAM and checking power connections
• You want to reuse parts you already own

A middle path worth knowing: many sellers offer configurable systems where you pick the CPU, GPU, and storage at checkout. That gets you custom specs with a single warranty.

Match specs to what you actually do

Don't buy by tier names alone — match the component to the workload.

• Gaming: GPU is the priority. Spend the largest share of your budget there, then on a CPU that won't bottleneck it. 16 GB RAM is a reasonable floor; 32 GB helps with heavily modded games and background apps.
• General work and study: A modern mid-range CPU, 16 GB RAM, and a fast SSD matter more than a discrete GPU. Integrated graphics are fine unless you game or do GPU-accelerated work.
• Workstation and AI tasks: Prioritize CPU core count, RAM capacity, and GPU VRAM. These workloads often care more about memory and VRAM than about clock speed. Check that your chosen software supports your GPU platform before buying.
• Storage: An NVMe SSD for the OS and active projects; add a second drive for bulk storage. Capacity needs vary widely, so size to your actual file volume rather than a default.

For laptops specifically, the same logic applies but with less room to fix mistakes — RAM and storage are often the only upgradeable parts, so buy the configuration you'll want in two years, not just today.

Set a realistic total budget

The sticker price is rarely the full cost. Budget for:

• Desktop: monitor, keyboard, mouse, speakers or headset, and possibly a Windows license if not included
• Laptop: a cooling pad or stand if you'll run sustained loads, plus any dock or extra charger you need
• Both: shipping, and tax where applicable

A useful approach: decide your all-in number first, subtract peripherals, then shop for the machine with what's left. This prevents the common mistake of spending the entire budget on the tower and having nothing left for a display.

Before you order: checks that prevent returns

• Return policy and warranty: Confirm the return window and who honors the warranty — the seller or the manufacturer. Policies differ between prebuilt systems and individual parts.
• Seller reputation: On a marketplace, check the seller's rating and history, not just the product rating.
• Compatibility (custom builds): Verify CPU socket matches motherboard, RAM type (DDR4 vs DDR5) matches the board, GPU length fits the case, and the power supply wattage covers your components with headroom.
• Power and space: Check your wall circuit and desk or floor space for the case you're considering.
• Laptop specifics: Confirm the exact GPU wattage and whether RAM/storage are soldered, since these aren't always obvious from the model name.

A quick decision path

1. Do you need to use the computer away from a desk regularly? Yes → laptop. No → desktop.
2. Desktop: do you want to use it immediately with one warranty, or specify and upgrade parts yourself? Immediate → prebuilt. Specify/upgrade → custom build.
3. Match GPU, CPU, RAM, and storage to your primary workload, not to marketing tiers.
4. Add peripherals and shipping to your budget before comparing prices.
5. Verify return policy, warranty provider, and — for custom builds — part compatibility before checkout.

You can judge a laptop's Linux compatibility before buying by checking four component families — Wi-Fi chipset, GPU, touchpad, and power management — against real-world reports in a hardware database such as Linux Hardware Database (linux-hardware.org), then confirming with a Live USB boot on the actual machine. The database tells you what other owners of the same model experienced; the Live USB tells you what this specific unit does. Use both, because a model can ship with different Wi-Fi cards or panel revisions across batches.

The four components that decide most compatibility outcomes

Most "works out of the box" versus "needs tinkering" differences come down to a small set of parts. Check these first; everything else (storage, USB controllers, audio) is usually handled by the kernel without extra work.

A laptop can pass three of these and fail the fourth, so treat them as separate checks rather than one overall verdict.

Querying the Linux Hardware Database by model or component

Linux Hardware Database collects hardware probe reports uploaded by Linux users, so its value is that entries reflect machines that actually booted Linux — not vendor spec sheets.

By laptop model: Search the model name or vendor plus model number. Probe reports typically list the kernel version used, the distribution, and the detected components. Look for reports on a kernel close to the one you plan to run: a report from two years ago on an older kernel may not reflect current driver support, and conversely a very new model may have few or no probes.

By component: If you already know the Wi-Fi chipset or GPU model (from the vendor's spec page or a review), search that part directly. This is the more reliable route when a model has multiple configurations, because the database entry is tied to the actual chip, not the marketing name.

Reading a report: Focus on whether the component was detected at all, whether the report notes missing firmware or a non-functional device, and which kernel version was in use. A device that appears in the probe but is flagged as not working is a stronger warning than a device that simply isn't listed.

Out-of-the-box versus "works with extra steps"

Sort what you find into three buckets before deciding:

• Works out of the box: Component detected, driver loaded automatically, no notes about firmware or kernel parameters. This is what you want for Wi-Fi and touchpad especially.
• Works with firmware or a newer kernel: The driver exists but needs a firmware package installed or a kernel newer than the distribution's default. Common for recent Wi-Fi and GPU parts. Acceptable if you're comfortable installing firmware or running a newer kernel.
• Needs out-of-tree drivers or kernel parameters: Vendor driver packages, DKMS modules, or boot parameters to fix suspend, backlight, or touchpad behavior. Workable, but each kernel update can break it — weigh this against how much you value low maintenance.

If a laptop's Wi-Fi falls in the third bucket, that alone is often a reason to choose a different configuration, since it affects every boot.

Confirming on the actual machine with a Live USB

Database reports are evidence, not proof for your unit. Boot a Live USB of the distribution you intend to use and check the hardware directly. The commands below read hardware state; none of them change the system.

1. Boot the Live USB and connect to Wi-Fi if possible. If Wi-Fi doesn't appear, that itself is the finding.
2. List PCI devices (GPU, Wi-Fi, Ethernet):

   lspci -nnk
   

   The -nnk flags show numeric vendor/device IDs and which kernel driver is in use. A device with no "Kernel driver in use" line is a red flag.
3. List USB devices (Bluetooth, webcam, some touchpads):

   lsusb
   

4. Check the kernel log for errors and missing firmware:

   dmesg | grep -i -E "firmware|error|fail"
   

   Messages about missing firmware files point to the "works with extra steps" bucket.
5. Test the touchpad and suspend: move the cursor, try two-finger scrolling, then suspend and resume. Suspend/resume failures are easier to catch now than after purchase.
6. Check sensors and power:

   sensors
   

   If temperatures or fan readings are absent, power management support may be incomplete.

Run these on the exact configuration you plan to buy — in a store if possible, or confirm the return policy before ordering.

When something isn't recognized

Troubleshoot by component type rather than reinstalling or switching distributions:

• Wi-Fi missing: confirm the chipset with lspci -nnk, then check whether a firmware package for that vendor is available in your distribution's repositories. If the driver isn't in the kernel, the database report will usually name the out-of-tree module others used.
• GPU or display issues: check whether the correct driver module is loaded, and whether the problem appears only with external monitors or after suspend.
• Touchpad not responding: verify it's detected as an I2C device; newer kernels often add support, so a kernel upgrade may resolve it.
• Suspend, fans, or battery: these usually trace back to ACPI quirks. Look for reports from owners of the same model, since fixes tend to be model-specific kernel parameters.

If a component remains unsupported after these checks, the practical decision is whether that component is essential to you. A non-working fingerprint reader is an inconvenience; a non-working Wi-Fi card changes how you use the machine every day.