Arch Linux has a certain fame: do it yourself, or don’t even bother. It appeals to power users, those mythical beings who compile their whole systems just for the fun of it. However, as much as nobody wants to admit it, Arch isn’t actually hard. And it’s not annoying, either.
The installation is just a checklist, and not a particularly complex one. All that’s necessary is partitioning a drive (something done for any OS, though here non-graphical), format it (idem), mount it (basic Unix), pacstrap a few packages, set up a bootloader (copy-paste from the wiki) and configure a few text files by following templates that are, again, in the wiki. None of these steps require special intelligence or mystical Linux powers. They’re just… steps.
The Arch Wiki is famous for being comprehensive, and it genuinely is — almost pathologically so. Every configuration option explained, every possible failure mode anticipated. It’s right there. All of it. The problem isn’t that Arch is hard to learn; it’s that the community has convinced everyone that having to read documentation is somehow a herculean task. What we call “Arch skills” are just Linux skills with, to be honest, very few extra steps. Pacman is actually simpler and more predictable than apt and, once you get to taste Yay, there’s no turning back. Now, the difference can be summed up to the fact that other distributions hide these steps behind installers and GUIs, while Arch makes you do them manually. But manual doesn’t mean difficult — it just means manual. Same goes for cars, but that’s a whole other talk.
So let me prove it. Right now, I’m going to install Arch Linux and you’re going to realize it’s basically advanced paint by numbers. But first I’ll clarify that the command line isn’t something to be scared of because, despite what some say, it’s not an esoteric process, but a deterministic one. You type commands, things happen. The same commands produce the same results because it’s cause and effect, input and output (and the output is documented).
First step is to download the Arch Linux .iso and burn it into a bootable USB drive. On Windows, use Rufus. On macOS, I personally recommend BalenaEtcher. If you’re on Linux, then you can use the terminal with dd — though honestly, BalenaEtcher works there too and is much less prone to accidentally nuking the wrong drive. Then, reboot your computer and enter BIOS. There, make sure any secure boot setting is turned OFF and proceed to boot into the burnt USB.
Once it boots up, you’ll be on the terminal as root@archiso. This is the part where people panic, but remember: you’re just looking at a text interface instead of a graphical one. First thing is to partition the disk. I’ll assume your hardware is recent so it uses UEFI. We’ll create an EFI partition 512 MB in size (fat32), mounted in /boot/efi, then a root partition (/) where the system will reside, and a separate /home partition just so you don’t lose your files during the next reinstallation that life will inevitably bring your way. Note: we’ll go for a swapfile instead of a swap partition.
Before we mess around with partitioning, we must find out what’s the disk we’ll use. Run:
lsblk -o NAME,SIZE,FSTYPE,MOUNTPOINT
In my case, it’s ‘sda’. Yours might be ‘nvme0n1’ if you have an NVMe drive, or something else entirely. This is why we check instead of assuming.
The program we’ll use to partition the disk is accessed through the command
cfdisk /dev/sda
Create following partitions:
- sda1 -> 512M -> EFI System
- sda2** -> 60 G -> root (/)
- sda3 -> Rest -> home (/home)
The sizes are suggestions, not orders. If you have a 1TB drive and want to give root 100GB, go for it! Just make sure the EFI partition is at least 512MB because firmware can be picky.
Save and quit. For formatting:
mkfs.fat -F32 /dev/sda1
mkfs.ext4 /dev/sda2
mkfs.ext4 /dev/sda3
These commands are doing exactly what they say: making filesystems. FAT32 for the EFI partition, ext4 for everything else. Now we mount them, which is just attaching these partitions to directories so we can access them:
mount /dev/sda2 /mnt
mkdir /mnt/boot
mkdir /mnt/boot/efi
mount /dev/sda1 /mnt/boot/efi
mkdir /mnt/home
mount /dev/sda3 /mnt/home
This creates a directory structure that mirrors what the final system will look like. /mnt is standing in for what will eventually be / (root) on your installed system.
For the base installation, we’ll run:
pacstrap -K /mnt base linux linux-firmware vim nano sudo networkmanager grub efibootmgr os-prober
This one command is doing the heavy lifting of downloading and installing the fundamental packages that make up a Linux system. base is the bare minimum, linux is the actual kernel, linux-firmware is drivers for your hardware, and everything else is quality-of-life stuff so you’re not stuck in a system that can’t connect to the internet or edit files. Notice how we’re being explicit about what we want instead of accepting whatever a distribution decided for us.
Next, genfstab to set the mount points and arch-chroot to assume the identity of the new machine. Then we will proceed to the basics: time zone, locale, hostname, root password.
genfstab -U /mnt >> /mnt/etc/fstab
This generates the fstab file, which tells the system where everything is mounted. The -U flag uses UUIDs instead of device names, which is good because device names can change between boots. UUIDs don’t.
The bootloader I chose was GRUB, because it works and is straightforward. It’s already installed given the base installation step, along with efibootmgr, so now we point it to EFI and configure it.
arch-chroot /mnt
This command is a very elegant one: we’re now inside the new system as if we booted into it, even though you’re still technically running from the USB.
This is for my time zone, so change to yours accordingly:
ln -sf /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime
hwclock –systohc
The symlink sets the timezone, hwclock syncs the hardware clock to it.
Edit /etc/locale.gen by uncommenting en_US.UTF-8 UTF-8 and pt_BR.UTF-8 UTF-8 (again, my case).
locale-gen
echo “LANG=pt_BR.UTF-8” > /etc/locale.conf
echo “KEYMAP=br-abnt2” > /etc/vconsole.conf
echo “archlinux” > /etc/hostname
Add a user and wheel group:
passwd
useradd -m -G wheel -s /bin/bash zanetti
passwd zanetti
First command sets the root password. Second creates a user named ‘zanetti’ with a home directory (-m), adds them to the wheel group (-G wheel), and sets bash as their shell. Third sets their password.
Edit sudoers by uncommenting %wheel ALL=(ALL:ALL) ALL
EDITOR=nano visudo
This lets anyone in the wheel group use sudo.
As for the bootloader, run:
grub-install –target=x86_64-efi –efi-directory=/boot/efi –bootloader-id=GRUB
grub-mkconfig -o /boot/grub/grub.cfg
First command installs GRUB to the EFI partition. Second generates the configuration file that tells GRUB what to boot and how.
Enable NetworkManager so you have internet when you boot:
systemctl enable NetworkManager
Since I chose a swapfile instead of a swap partition, let’s create it:
fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo “/swapfile none swap sw 0 0” >> /etc/fstab
Allocate space for the swapfile, set permissions so only root can access it, format it as swap, activate it, and add it to fstab so it’s activated on boot.
Now that we have a system that exists and breathes, we will install KDE as the main desktop — plasma-meta, sddm, and such. To have a card up our sleeve, we’ll also add XFCE because it is lightweight, reliable, and great for when we inevitably decide to change something and everything goes down the drain.
pacman -S xorg sddm plasma kde-applications xfce4 xfce4-goodies
This installs the X server (the thing that draws windows on your screen), SDDM (the login manager), KDE Plasma (the desktop environment), and XFCE as backup. One command. Compare this to downloading installers for each component on Windows…
Activate the display manager:
systemctl enable sddm
Now, for some nice extras before we boot into the system, I chose to install these:
pacman -S konsole dolphin firefox git wget base-devel openssh
Terminal emulator, file manager, browser, version control, and development tools.
Enable SSH so you can remotely access the machine if needed. Optional, but useful.
systemctl enable sshd
It’s all done! Now just restart by running:
exit
umount -R /mnt
reboot
Exit the chroot, unmount everything, reboot. If you’ve followed the steps, you’ll boot into SDDM, log in, and have a fully functional Arch Linux system.
See? Nothing magical, nothing fancy. Well, maybe a little fancy. And, if I remember well, it’s actually faster than installing Ubuntu.
The beauty of Arch is that what you just installed is a foundation, not a finished product. For those who want to go full aesthetics mode, there’s a whole world of customization waiting. You can theme KDE to look like macOS, Windows 11, or something entirely unique. There are people who’ve recreated the Mac OS X Leopard interface on KDE — yes, complete with the translucent menu bar and the dock animations. Or as I call it, Slow Leopard. Here is an example.
The point to be made here is as simple as it can be: you’re not locked into anything. You built this system command by command, know what’s in it and can change any part of it without breaking some mysterious dependency chain that an installer created.
Leave a Reply