linux-hardware.org

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.

Arx Libertatis is an improved, cross-platform, open-source engine for Arx Fatalis, the 2002 first-person RPG/dungeon crawler/immersive sim from Arkane Studios. To play on Linux, you install Arx Libertatis (official Linux builds are provided), then point it at a copy of the original Arx Fatalis game data — the engine itself does not include the game. You need to own or otherwise obtain Arx Fatalis or its demo before you can play.

What Arx Libertatis actually is

Arx Libertatis is a port and modernization of the Arx Fatalis engine, based on the publicly released Arx Fatalis source code and available under the GPL 3+ license. Version 1.2.1 supports modern systems, brings the game to new platforms, and removes bugs and limitations of the original release.

Two things follow from that:

• The engine is free and open source. You can download, inspect, and redistribute the code under the GPL.
• The game data is not included. The license covers the engine only. The art, audio, levels, and other assets remain part of the commercial game, so you must supply them yourself.

The game itself features crafting, melee and ranged combat, and a distinctive spellcasting system where you draw runes in real time to cast the spell you want.

What you need before installing

The original game is sold through storefronts such as GOG.com, the Microsoft Store, and the Bethesda Store, and it also has a demo. Any of these gives you the data files the engine needs.

Installing Arx Libertatis on Linux

Arx Libertatis provides official builds for Windows and Linux. Beyond those, it has been packaged for macOS (Homebrew), FreeBSD, DragonFly BSD, NetBSD, OpenBSD, Haiku, and Pandora, and will likely compile and work on other operating systems.

On Linux, you have two practical routes:

Option 1: Use a distribution package

Check whether your distribution ships Arx Libertatis in its repositories. If it does, install it through your normal package manager. This is the least manual path and keeps updates tied to your system.

Option 2: Use the official Linux build

Download the Linux build from the project's download page and unpack it. This works regardless of whether your distribution packages the engine, and it lets you run a specific version such as 1.2.1.

If neither fits, the source is available on GitHub, so you can build it yourself — the project notes it will likely compile on other systems too.

Pointing the engine at your game data

The engine needs to find the Arx Fatalis data files. The general flow is:

1. Install or unpack Arx Libertatis using one of the routes above.
2. Locate your Arx Fatalis data. If you bought the game from a storefront, the installer places the data files somewhere on disk; if you have the demo, it comes as its own set of files.
3. Tell Arx Libertatis where that data is when you first launch it, or place the data where the engine expects it.
4. Launch the game and confirm it reaches the main menu.

The expected result at each step is simple: the engine starts, finds the data, and loads the game rather than exiting with a "data not found" style error.

If the game does not run

Check these in order:

• Data path is wrong. The most common failure is the engine not finding the Arx Fatalis data. Re-check the path you gave it.
• You installed the engine but not the game. Arx Libertatis alone cannot run — it has no assets of its own.
• Graphics/driver problems. Since the engine targets modern systems, most rendering issues trace back to drivers or to running an old build. Try the current release (1.2.1).
• Wrong build for your system. Make sure you grabbed the Linux build, not the Windows one, if you installed manually.

Where to go next

The project plans to keep improving and modernizing the engine and to enable community customizations and mods. If you want to follow development or get help, the project links to its GitHub repository, Mod DB page, and community forums such as the TTLG Forum and the GOG.com forum. There are also community projects built around the game, including the Arx Insanity Mod and other Arx mods.

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.

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.

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.