My First Arch Linux Install: A Basic Setup on an Old Laptop

arch linux
linux
installation
dotfiles
bootloader
grub
systemd
A from-scratch, copy-pasteable walkthrough of installing Arch Linux 2026.05.01 on an old test laptop — verifying the ISO, booting the live environment, partitioning, pacstrapping the base system, configuring locale and users, and installing GRUB. No BTRFS, no LUKS, no zram. Just a clean, opinionated first install.
Author

Evanns Morales-Cuadrado

Published

May 1, 2026

What this is

This is a personal install log: the basic Arch Linux install I did on an old laptop as my entry point into the distribution. I deliberately kept it simple — no Btrfs subvolumes, no full-disk encryption, no zram. Just ext4, a swap partition (so I can play with hibernation later), and separate / and /home partitions. The more ambitious dual-boot, encrypted, snapshot-able workstation is the next article in this Tech Zone.

Why an old laptop, and why basic?

I’m planning to migrate my main laptop and my desktop to a dual-boot Ubuntu + Arch setup with Btrfs subvolumes, LUKS full-disk encryption, zram for everyday swap, and a dedicated encrypted swap partition for hibernation. That is the long-term goal.

But I have never installed Arch before. Doing a maximalist install on the machines I work from every day is how you end up unable to write your dissertation chapter on Monday morning. So this article walks through the boring, dependable, first-time install on an old laptop I don’t care about bricking. Once I have the basic mental model — pacstrap, chroot, mkinitcpio, grub-install, the systemd service ecosystem — the next round can layer Btrfs, LUKS, and zram on top with confidence.

The ISO I’m using is archlinux-2026.05.01-x86_64.iso, the May 2026 monthly snapshot. Anything in this guide that depends on a specific kernel version or package set should still work on later snapshots, but commands like cfdisk and pacstrap are the same across releases — Arch is rolling, so the install media just bootstraps you to a current state.

I borrow structure and a handful of phrasings from Radley Lewis’s excellent Arch installation guide — go read it if you want a second voice on the same material. The commentary, choices, and mistakes here are mine.

Part 1 — System Setup and Arch Install

Chapter 0: Preparation

Before you touch the laptop, get your ISO and verify it on a machine you trust.

  1. Visit the Arch Linux download page.
  2. Make a working directory so you can keep everything in one place — I used ~/Downloads/Arch.
  3. Grab three files from one of the mirrors (I scrolled to the first US mirror — adectra):
    • the ISO (archlinux-2026.05.01-x86_64.iso, about 1.4 GiB),
    • its signature (archlinux-2026.05.01-x86_64.iso.sig),
    • the sha256sums.txt checksum file.

Verify the checksum

cd ~/Downloads/Arch
sha256sum -c sha256sums.txt

You should see:

archlinux-2026.05.01-x86_64.iso: OK

This confirms the file you have on disk byte-for-byte matches the one published in the checksum file. A bad mirror or a corrupted download would fail here.

Verify the signature

A checksum tells you the file matches what the mirror serves. A signature tells you it was actually published by the Arch Linux release engineer (Pierre Schmitz at the time of writing). Both are worth checking.

gpg --auto-key-locate clear,wkd -v --locate-external-key pierre@archlinux.org
gpg --verify archlinux-2026.05.01-x86_64.iso.sig archlinux-2026.05.01-x86_64.iso

You should see:

gpg: Good signature from "Pierre Schmitz <pierre@archlinux.org>" [unknown]
About the “key is not certified” warning

You will also see:

gpg: WARNING: The key's User ID is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.

This is expected. It means you haven’t personally signed Pierre’s key as part of your local web of trust. The signature itself is still valid — gpg just can’t prove the key belongs to who it claims to. For a one-off install on a personal laptop, this is fine.

Burn the ISO to a USB drive

I used balenaEtcher: download the Linux x86 zip, unzip, run the executable, follow three steps (pick image, pick drive, flash). Done.

If you prefer the command line, dd works too — just be very careful with of=.

Chapter 1: Booting the Install Media

  1. Plug the USB into the target laptop.
  2. Interrupt the normal boot process and select the USB. On most systems this is F2, F10, F12, or Esc, or you set the USB first in the UEFI boot order.
  3. From the Arch ISO boot menu, pick the default “Arch Linux install medium” entry.

Once you land at the root shell, verify you booted in UEFI mode (everything below assumes UEFI, not legacy BIOS):

cat /sys/firmware/efi/fw_platform_size

You should see 64 (or 32 on very old hardware). If the file does not exist at all, you booted in BIOS mode and you’ll need to fix your firmware settings before continuing.

If your console font is too small to read comfortably on a high-DPI display, bump it up:

setfont ter-132b

Chapter 2 (Optional): SSH In From Another Computer

I do this every time. My old test laptop’s keyboard is partly broken and I’d rather not type a full install through it. SSHing in from my newer machine also means I can keep the install guide open on one monitor while running commands on the other.

Get on Wi-Fi with iwctl

iwctl

Inside the interactive prompt:

device list
station wlan0 scan
station wlan0 get-networks
station wlan0 connect "My SSID Name"

Use quotes around any SSID with spaces. Replace wlan0 with whatever your card is actually called from device list. Then exit to leave iwctl.

Confirm you have a connection:

ping -c 5 ping.archlinux.org

Find your IP

ip addr show

Look at the wlan0 block for an inet xxx.xxx.xxx.xxx/yy line. That’s the address you’ll SSH into.

Make sure the SSH daemon is running

systemctl status sshd

If it isn’t already running:

systemctl enable --now sshd
openssh vs. ssh vs. sshd

A trio that confused me at first.

  • openssh is the package — the upstream project that ships both the client and the server.
  • ssh is the client binary you run on your laptop to connect into something.
  • sshd is the server daemon that listens for incoming connections.

In the Arch live environment, openssh is already installed, the ssh client is available, and sshd is the systemd unit that needs to be enabled before you can SSH into the live USB from another machine.

Set a root password and connect from your other machine

passwd

This is only for the live environment — you’ll set a separate password for the installed system later. Then from any other computer on the same network:

ssh root@<ip-address-from-earlier>

The rest of this guide is much more comfortable from a real keyboard.

Chapter 3: Keyboard, Timezone, and Time Sync

Keymap

localectl list-keymaps    # see all available layouts
loadkeys us               # I use a US layout

Timezone

timedatectl list-timezones | grep America
timedatectl set-timezone America/New_York

Enable NTP

timedatectl set-ntp true
What set-ntp true actually does

timedatectl set-ntp true tells systemd-timesyncd to sync the system clock against network time servers (NTP). Without it, the live environment’s clock drifts based on whatever the hardware clock says, which can cause TLS handshakes and pacman operations to fail with mysterious certificate errors if the clock is far enough off. Turning it on is essentially free, so always do it.

Chapter 4: Partitioning

For this basic install I’m using four partitions on one NVMe SSD:

Partition Size Filesystem Purpose
EFI System 1 GiB FAT32 UEFI bootloader (GRUB lives here)
Swap 35 GiB swap Suspend-to-disk / hibernation
Root (/) 200 GiB ext4 OS and applications
Home (/home) remainder ext4 User data

Separate / and /home partitions mean I can reinstall Arch later without nuking my home directory. Not strictly necessary, but it’s the kind of habit that pays off the first time you want to wipe and try again.

Find the SSD

fdisk -l

The disk you want is the big one — usually nvme0n1 on modern laptops (the NVMe naming reflects how SSDs talk to the motherboard over PCIe). Note its full path: /dev/nvme0n1.

Edit the partition table

cfdisk is a TUI tool that makes partitioning much less painful than raw fdisk:

cfdisk /dev/nvme0n1

Inside cfdisk:

  1. Press d on every existing partition to delete it. Nothing is committed until you press w, so this is your scratch space.
  2. Press n to create new partitions. Set each one’s size and partition type:
    • 1 GiB EFI System
    • 35 GiB Linux swap
    • 200 GiB Linux filesystem
    • remainder Linux filesystem
  3. Press w to write, type yes to confirm.

Verify the new layout:

lsblk
fdisk -l

You should see nvme0n1p1 … nvme0n1p4 with the sizes you set.

Chapter 5: Format and Mount the Partitions

The partition table tells the disk which bytes belong to which slice. The filesystem tells the kernel how to read and write files inside that slice. Two different things, two separate commands.

Format

mkfs.fat -F32 /dev/nvme0n1p1    # EFI System Partition (FAT32 — required by UEFI spec)
mkswap        /dev/nvme0n1p2    # Swap area
mkfs.ext4     /dev/nvme0n1p3    # Root filesystem
mkfs.ext4     /dev/nvme0n1p4    # Home filesystem

The EFI partition must be FAT32 — the UEFI specification mandates it. Everything else is your choice; I’m going with ext4 because it is rock-solid, well-understood, and has no exotic features I’ll need before I rebuild with Btrfs in the next article.

Mount

Mounting is how you attach a partition to a directory tree so the OS can actually use it. The Arch install lives in /mnt from the live environment’s point of view — that becomes / from the installed system’s point of view after reboot.

mount /dev/nvme0n1p3 /mnt              # mount root first
mkdir -p /mnt/{boot,home}              # create mount points inside the new root
mount /dev/nvme0n1p1 /mnt/boot         # EFI partition at /boot
mount /dev/nvme0n1p4 /mnt/home         # /home
swapon /dev/nvme0n1p2                  # activate swap
Order matters

You must mount /mnt before creating /mnt/boot and /mnt/home, because those directories need to live inside the new root partition (otherwise they would exist only in the live USB’s tmpfs and disappear after reboot).

Verify

lsblk
mount | grep /mnt
swapon --show

You should see all three partitions mounted under /mnt and the swap device active.

Recovery: starting the mount step over

If you mis-mounted something or activated swap twice, nothing is broken — you can cleanly reset the mount state and start over.

swapoff /dev/nvme0n1p2     # ignore errors if swap isn't on
umount -R /mnt             # recursively unmount everything under /mnt
mount | grep /mnt          # should print nothing

# Remount cleanly
mount /dev/nvme0n1p3 /mnt
mkdir -p /mnt/{boot,home}
mount /dev/nvme0n1p1 /mnt/boot
mount /dev/nvme0n1p4 /mnt/home
swapon /dev/nvme0n1p2

Chapter 6: Install the Base System

This is the moment Arch stops being a USB stick and starts being a real OS on your disk.

Why this order matters

pacstrap creates /mnt/etc, /mnt/bin, /mnt/usr, and the rest of the standard Linux directory layout. genfstab needs /mnt/etc to already exist before it can write fstab into it, and arch-chroot needs a complete system inside /mnt (kernel, libc, bash) to chroot into. So: pacstrap first, then fstab, then chroot.

1. Refresh the mirror list

pacman downloads packages from mirrors. The default mirror list is geographically random — reflector ranks them by speed and recency so your installs are fast.

reflector \
  --country 'United States' \
  --protocol https \
  --latest 20 \
  --age 12 \
  --sort rate \
  --save /etc/pacman.d/mirrorlist

You can preview the current list first with less /etc/pacman.d/mirrorlist.

2. Bootstrap the base system

pacstrap -K /mnt base linux linux-firmware \
    grub efibootmgr networkmanager sudo neovim \
    git base-devel intel-ucode

The -K flag initializes a fresh pacman keyring inside /mnt. Without it, pacman running inside the chroot later would inherit the live ISO’s keyring, which can cause confusing key-trust errors during your first pacman -Syu.

Here’s what each package is for:

Package Why it’s here
base Minimum set of utilities that make the system Arch (coreutils, glibc, bash, systemd, etc.).
linux The actual Linux kernel image.
linux-firmware Binary firmware blobs for Wi-Fi, GPU, Bluetooth, etc. Without this, your hardware may not work.
grub GRUB 2 bootloader — selects the kernel and hands off control to it.
efibootmgr CLI tool to manage UEFI boot entries. grub-install calls it under the hood.
networkmanager Manages Wi-Fi/Ethernet from inside the installed system (we used iwctl only because the live USB doesn’t ship NetworkManager).
sudo Lets non-root users run privileged commands.
neovim My editor of choice. Swap for nano or vim if that’s your taste.
git Needed for fetching dotfiles, AUR helpers, basically anything later.
base-devel make, gcc, pkgconf, fakeroot, etc. — required for building AUR packages.
intel-ucode Early CPU microcode updates for Intel chips. Use amd-ucode instead if your laptop has an AMD CPU.

3. Generate fstab and chroot in

genfstab -U /mnt >> /mnt/etc/fstab
arch-chroot /mnt

genfstab scans the currently mounted partitions and writes their UUIDs into /mnt/etc/fstab. Using -U (UUIDs) instead of -L (labels) is the safer default — UUIDs survive disk renaming. The >> appends to the file; do not use > (it would overwrite anything already there).

arch-chroot /mnt is a smarter chroot — it mounts /proc, /sys, /dev, and a few other API filesystems inside /mnt first, so things like pacman work normally from inside the new system. After this command, your shell prompt is “inside” the new Arch install.

Chapter 7: Inside Arch (Part 1)

This chapter is the configuration walk-through that runs inside the chroot: setting the editor, locale, timezone, hostname, root password, user account, and a second wave of useful packages. Each step writes to a config file in /etc/ or runs a one-shot command that takes effect after reboot.

0. Make Neovim the default editor

echo 'export EDITOR=nvim' >> ~/.bashrc
source ~/.bashrc

This applies inside the chroot session. For my user account I’ll set it again later.

1. Timezone and hardware clock

ln -sf /usr/share/zoneinfo/America/New_York /etc/localtime
hwclock --systohc
  • The ln -sf creates a symlink from /etc/localtime to the zoneinfo file that describes how to interpret your local time (UTC offsets, DST transitions). Programs read this to display “wall clock” time.
  • hwclock --systohc writes the current system time back to the motherboard’s hardware (RTC) clock. The hardware clock is what the system reads on power-up before NTP kicks in, so syncing it now means the first few seconds of every boot show roughly correct time.

2. Locale

nvim /etc/locale.gen

Inside locale.gen, find and uncomment the two en_US.UTF-8 lines (or whichever locale you want). Save and exit, then:

locale-gen
echo "LANG=en_US.UTF-8" > /etc/locale.conf
echo "KEYMAP=us" > /etc/vconsole.conf

locale-gen compiles the uncommented locales into binary form. locale.conf sets the system-wide language; vconsole.conf sets the keymap that the virtual console uses before any graphical session starts.

3. Hostname

echo "your-hostname-here" > /etc/hostname

This is the machine’s name on your network (hostname reads it, NetworkManager publishes it via mDNS if you have avahi running later).

4. Enable NetworkManager at boot

systemctl enable NetworkManager

Without this, the installed system will reboot into a state with no Wi-Fi or Ethernet manager running.

5. Set the root password

passwd

6. Create your user account

useradd -m -g users -G wheel evanns
passwd evanns

Replace evanns with whatever your username should be. Flag-by-flag:

  • -m — create a home directory at /home/evanns.
  • -g users — primary group is users.
  • -G wheel — also add the user to the wheel group.

The wheel group is a Unix convention going back to early BSD: it’s the group of people allowed to become root. On Arch (and most modern distros), you grant sudo privileges by enabling sudo for everyone in wheel — not by listing each user individually.

7. Enable sudo for the wheel group

visudo

Find this commented-out line:

## Uncomment to allow members of group wheel to execute any command
# %wheel ALL=(ALL:ALL) ALL

Remove the leading # on the %wheel line, save, and exit. From now on, any user in the wheel group can run sudo.

8. Install more core packages

pacman -Syu \
  linux-headers \
  mtools \
  network-manager-applet \
  openssh \
  iptables-nft \
  ipset \
  firewalld \
  reflector
Package Why
linux-headers Kernel headers — required to build out-of-tree modules (DKMS, NVIDIA, ZFS, …). Skip only if you know you’ll never build a module.
mtools Userspace utilities for manipulating FAT filesystems — handy when poking at the EFI partition.
network-manager-applet Tray icon for switching networks from a desktop environment. Skip on headless systems.
openssh SSH client and server (ssh and sshd). I want to SSH back in after reboot.
iptables-nft nftables-backed iptables binary. Modern replacement for legacy iptables.
ipset Lets the firewall match against large IP sets efficiently. Useful even if you don’t use it directly — many tools depend on it.
firewalld Friendly firewall daemon with zones (home / work / public). Optional, but I prefer it over hand-writing nftables rules.
reflector Same mirror-ranker we used from the live ISO; install it inside the system so it can refresh the mirror list on a timer.

9. Install more useful packages

pacman -Syu \
  man-db man-pages texinfo \
  bluez bluez-utils bluez-deprecated-tools \
  alsa-utils \
  pipewire pipewire-pulse \
  sof-firmware \
  ttf-iosevka-nerd \
  kitty \
  firefox

When pacman asks which JACK provider to use, pick pipewire-jack. When it asks which font provider for emoji, pick noto-fonts.

Package Why
man-db man-pages texinfo Man pages and info pages. Skip only if you genuinely never read documentation locally.
bluez bluez-utils bluez-deprecated-tools Bluetooth stack. Drop on a desktop without Bluetooth.
alsa-utils Low-level audio utilities (alsamixer, aplay).
pipewire pipewire-pulse Modern audio stack; pipewire-pulse provides drop-in PulseAudio compatibility.
sof-firmware Sound Open Firmware — needed by most modern Intel laptop audio codecs.
ttf-iosevka-nerd My terminal font, patched with Nerd Font icons.
kitty My terminal emulator. Pick alacritty, wezterm, or foot if you prefer.
firefox Browser. Optional in the strict sense — you can install your browser of choice later.

Chapter 8: Inside Arch (Part 2) — Bootloader and Services

This is the home stretch: install GRUB so the machine can actually boot the kernel from disk, and enable the systemd services that should come up on every boot.

1. Install GRUB to the EFI partition

grub-install --target=x86_64-efi --efi-directory=/boot --bootloader-id=GRUB

This writes the GRUB EFI binary into /boot/EFI/GRUB/, registers it with the firmware via efibootmgr, and sets up /boot/grub/ for the runtime config.

You can confirm everything landed:

ls /boot

Expected (something close to):

EFI  grub  initramfs-linux.img  intel-ucode.img  vmlinuz-linux

2. Generate the GRUB configuration

grub-mkconfig -o /boot/grub/grub.cfg

grub-mkconfig scans your kernels (/boot/vmlinuz-*), microcode images, and /etc/default/grub and writes a complete boot menu config to /boot/grub/grub.cfg. The output you see should end with done.

3. Enable services at boot

systemctl enable NetworkManager    # network management
systemctl enable bluetooth         # Bluetooth
systemctl enable sshd              # SSH server
systemctl enable firewalld         # firewall
systemctl enable reflector.timer   # weekly mirror re-rank
systemctl enable fstrim.timer      # weekly SSD trim
Why .timer units instead of cron

reflector.timer and fstrim.timer are systemd timer units — the modern replacement for cron jobs. They run their corresponding .service unit on a schedule (fstrim.timer defaults to weekly), log into the journal, and depend on the right targets so they don’t fire during boot or shutdown. You don’t need to install cron unless you really want to.

4. Exit, unmount, and reboot

exit              # leave the chroot
umount -R /mnt    # unmount everything
reboot

Pull the USB drive out as the laptop reboots, and the firmware should hand off to GRUB, GRUB should hand off to the kernel, and the kernel should hand off to systemd. If everything went well, you’ll get a login prompt for your new user.

Part 2 — Running Arch

Once you’re logged in, the first thing I do is reconnect to Wi-Fi from NetworkManager (nmcli device wifi connect <SSID> password <pw> works well via SSH), then install a small set of build tools so I can start playing:

sudo pacman -Syu git wget curl gcc make cmake

From here, the rest of “making Arch yours” is a series of separate articles — Neovim from scratch, picking a tiling or scrolling window manager, dotfiles management, audio routing, fonts. Those will land in this Tech Zone as I go.

What’s next

This was the deliberately boring first install. The next article is the opposite — my attempt to do all of this plus LUKS full-disk encryption, Btrfs subvolumes (@, @home, @snapshots), zram for everyday swap, and a dual-boot side-by-side with Ubuntu. It did not boot. It taught me a lot. That post-mortem is up next.

Attribution

The Arch Linux logo is a trademark of the Arch Linux project and is used here under Arch Linux’s branding terms for editorial purposes only.