How I install Arch Linux, not using the guided installation script: A beginner-friendly tutorial#

There already are many guides out there for how to install Arch Linux, on YouTube in video form and in written form. I watched most if not all videos that someone doing a simple Google/YouTube search would find. Here I present to you what I compiled after watching all of them, and after reading the official installation guide on the ArchWiki in 2026. I present to you a "best of", so to speak, after gathering from each consulted resource what it had to offer and after removing/updating commands that are now obsolete or no longer best practice (like installing the (U)EFI applications within /boot/efi rather than in /efi).

My goal in particular is to explain each command and not just to show it. Otherwise you might be right in questioning why the world needed yet another installation guide. While I give my best to explain every command and keep this tutorial beginner-friendly, I will teach you advanced and very advanced Linux concepts from which you don't need to shy away after my explanations, that I didn't see covered in most of the existing resources other than the ArchWiki. I make the case that a written guide is more appropriate than a guide in video form, simply because you don't have to pause or rewind every few seconds as with a video.

What makes this guide stand out#

Although the ArchWiki is a most excellent resource that you should definitely read—something that every guide says, to the point that it's become a trope, but it's true—I found the official installation guide on the ArchWiki a bit hard to follow at times as someone new to Arch precisely because it's so extensive. For a wiki and knowledge base, being extensive is a good thing, especially after having read some secondary literature, but for a beginner requiring a straight-forward path through the freedom of choices that Arch allows, I myself found the information in the wiki overwhelming. It covers every possible scenario imaginable, and as someone who uses fairly modern hardware I simply didn't care about the instructions for how to proceed if I were installing Arch on ancient hardware. For example, it used to be common practice to install the files used by the bootloader in /boot when BIOS was still a thing, and when BIOS was succeeded by UEFI, people started to install the (U)EFI applications in /boot/efi, but the currently recommended location for (U)EFI applications is /efi. The ArchWiki covers all three scenarios: installing in /boot/efi, /boot and /efi. Reading the ArchWiki, I wished for a simpler guide to follow that cuts through the complexity and provides a clear path for what I consider the "normal case" in 2026 for everyone who would search for an installation guide in the first place: a mainboard that isn't older than ten years (thus uses UEFI, not BIOS); uses only SSDs (NVMe and/or SATA), no HDDs; doesn't use CD-ROM drives, floppy disks, or other ancient technology.

What I also noticed while learning from Arch Linux experts with decades of experience is that many of them apparently wrote their installation routine 20 years ago and haven't updated it since. So, while they're definitely more experienced than I am—I only recently migrated from macOS to GNU/Linux—I found that their advice often contained outdated information, even information discouraged from following. Having recently combed through all the information I could find, I'm confident that my tutorial is the best "secondary literature" guide you can find. 🙂

I also try to avoid systemd commands in this guide where Arch allows it, although every mainstream Linux distribution uses systemd. I like OpenRC better than systemd and I therefore "graduated" from Arch Linux to Gentoo Linux. You might not know it, but Arch is not the most advanced Linux distribution out there. For desktop computers I prefer Gentoo Linux which is even more customizable than Arch, and for containers I prefer Alpine Linux, both of which are Linux distributions that allow you to use OpenRC instead of systemd. If you learn how to do things without systemd, you'll be able to use any Linux distribution, not just those that force you to depend on systemd.

Most concepts you learn through the installation and usage of Arch can be directly transferred to distributions not based on systemd, such as Gentoo or Alpine. I write the guide for Arch Linux both 1) because for someone not already familiar with Arch it's probably a bit hard to learn the ropes on a source-based distribution like Gentoo rather than on a binary-based distribution like basically every other distribution (including Arch) and 2) because it's more often googled than an installation guide for Gentoo.

I have automated most of the steps with code snippets. You should't need to perform the outlined steps manually. I chain commands together when it makes sense, using &&, to stop the chain of commands when one command in the chain fails rather than continuing with nonsensical values from previous command that failed unnoticed. This makes the commands multi-line commands. Just paste the next snippet into your terminal. The :? in ${whatever:?} just ensures that you never forget to set the variable whatever before executing a command that uses it in order to avoid continuing with nonsensical empty variables. In case you don't understand any command, don't hesitate to contact me.

Prerequisites#

In the UEFI (often wrongly called BIOS), disable UEFI Secure Boot. You can enable it again after Arch has been installed, but Secure Boot needs to be disabled during installation. Consult your computer's/mainboard's manual or search the internet to learn which key you need to press during the boot process to interact with your mainboard's firmware.

BIOS (Basic Input/Output System) is a legacy term. BIOS firmware is obsolete and has been obsolete for a long time. Its successor is UEFI (Unified Extensible Firmware Interface). Unless you use ancient hardware or a bare-metal EC2 (Elastic Cloud Compute) instance on AWS, your computer uses UEFI, not BIOS. This tutorial assumes you use UEFI. Unlike the ArchWiki, this guide doesn't consider the possibility that you use BIOS. My guide should therefore be easier to follow. That's at least my goal in writing this tutorial. 🙂

Oh, and you need a thumbdrive, of course. The Arch installation ISO is about 1.5 GiB large.

Preparation#

Before you can begin with the installation and boot (perhaps for the first time) into a live Arch environment, you need a bootable thumbdrive that has Arch flashed to it. In this preparation section we take care of creating such a bootable thumbdrive and booting into it before we move on to the actual installation in the next section.

Even sooner, I will confront you with some questions you will sooner or later have to answer when you use a DIY operating system like Arch. Some of these questions you might've never thought about before, even if you've used computers for 20 years. They really get down to the nitty-gritty details and finding satisfying answers to these questions is the hardest part about Arch, in my opinion. Anyone can type a list of commands into the terminal and copy someone else's setup (perhaps even without understanding it), but what are your requirements? What do you want out of a customizable DIY system you can tailor to your preferences? If you don't enjoy pondering the following questions, then nobody will judge you if you stick to a less-DIY distribution such Fedora or Mint.

Planning#

Although the process of installing Arch is daunting for someone installing Arch for the first and even second time, and for someone who doesn't yet know the ins and outs of partitioning disks, installing filesystems, mounting filesystems, et cetera, the process is just executing a bunch of commands in the right order. You don't even have to understand them if someone hands you a list with commands to execute. Once you've installed Arch a few times, you'll be able to do it in less than ten minutes. You'll even know most commands and their order by heart. Many commands have sensible defaults whereas other commands require complex configurations/options if you want to get the best out of your system, which is likely the case if you decide to install Arch and not simply use some other Linux distribution. Executing a bunch of commands isn't what makes Arch hard to install. Even the thought process behind command flags that let you achieve results superior to invoking the command with its default flags isn't what gives Arch the reputation for being hard to install. In my opinion, it's all the planning that has to happen before you execute a single command that makes Arch hard to install: How many partitions do you want? If you want two partitions on the same disk, do you want the split to be 50:50? 80:20? Do you prefer partitions or logical volumes? Or BTRFS subvolumes if you use BTRFS? Do you want to use BTRFS, or Ext4? Where do you want to mount your EFI System Partition: /boot/efi, /boot or /efi? How big do you think you need to make your EFI System Partition? Or how small do you think you can make it? That depends on how many initramfs images you want to be able to use. Do you want a fallback image or no? How to do you want to name your device mapper files? Finding good, descriptive names is always hard, but finding good names requires a solid understanding of the technology for a start. Can you later easily rename things or will the names you choose be set in stone? Which sleep state do you want your computer to be able to achieve, suspend-to-RAM or suspend-to-disk? That influences how big a swap space you need. But remember, you cannot easily resize partitions if you later change your mind. Or do you prefer a swap file over a swap partition? Or maybe abstract away the partition as a logical volume with LVM (Logical Volume Manager)? How would you handle it if you spanned a volume group over more than one disk and one of those disks then failed, corrupting all your data? Play it safe and never span a volume group across more than one disk? But why then even use LVM?

Once you know your personal answer to all these questions, every installation is a matter of mere minutes. Switching jobs and having to reconfigure a new machine is no big deal. But it's a lot of upfront work to do the research, to do the learning, to think about what you want. Especially the "low-level" configurations (like the size of your partitions) are important to get right before you continue the installation process because you cannot change the size of a partition after the fact without losing the data on it. If you want to make changes, even small changes, to what you specified during the installation process, you have to go through the time-consuming process of migrating your data somewhere else, wiping the partition/disk, reconfiguring it from scratch, and migrating the data back, hoping you won't need to make another change. Which, when you don't yet know a lot of things, is unlikely. Of course you're going to notice things you could have done better as you learn new concepts or revise your existing knowlege. If you want the best possible Arch installation, you're going to re-install Arch over and over. Ignoring the time-consuming work of data migration if you're doing this on your production machine rather than on a virtual machine for practice, the installation itself is a process of just a few minutes once you've followed the process a few times.

What makes installing Arch hard, in my opinion, is coming up with answers to the questions stated above … ideally before you do the installation to avoid unnecessary work … when the time before the first installation is also the time when you know the least about Arch and cannot really answer the questions competently yet. This is where my tutorial comes into play. 🙂

Creating a bootable thumbdrive#

A brief overview over what's to come:

• Download the ISO disk image for the installer itself. You can download the ISO file from any mirror.
• These non-ISO files should be downloaded only from the official Arch website, not from a mirror, to avoid downloading files that were tampered with:
• One of the two checksum files (b2sums.txt or sha256sums.txt) to verify that the ISO was downloaded completely and correctly. b2sums.txt is better than sha256sums.txt.
• The OpenPGP signature to verify, after you verified the ISO was downloaded completely, that no malicious person tampered with the ISO file.

As I wrote above, I scripted everything you need, so continue reading. You don't need to do anything manually.

BLAKE2b is a better hash function than SHA-256, and only one of them is needed.

Downloading the required files#

A new ISO disk image is released on the first day of every month. I use the command date to determine the first day of the current month, then download the two non-ISO files from the Arch website itself:

mkdir --parents ~/Downloads/arch-iso && cd "${_}" &&

latest_release_date="$(date +%Y.%m).01" &&
checksum_filename='b2sums.txt' &&
iso_filename="archlinux-${latest_release_date:?}-x86_64.iso" &&

wget https://archlinux.org/iso/"${latest_release_date:?}"/"${checksum_filename:?}" &&
wget https://archlinux.org/iso/"${latest_release_date:?}"/"${iso_filename:?}".sig &&

The _ in $_ is a special variable that refers to the last argument of the previous command, to avoid having to duplicate the filepath. I might have just as well written cd ~/Downloads/arch-iso instead.

If you have no problems with a US company that is funded by Venture Capitalists, or if you're too lazy to look up a university from your own country, use the following code snippet to download the Arch ISO from Fastly's Content Delivery Network:

mirror_hostname='fastly.mirror.pkgbuild.com' &&
path_to_iso="iso/${latest_release_date:?}" &&

I myself choose a university from my homecountry instead:

mirror_hostname='ftp.halifax.rwth-aachen.de' &&
path_to_iso="archlinux/iso/${latest_release_date:?}" &&

Either way, download the ISO disk image:

wget https://"${mirror_hostname:?}"/"${path_to_iso:?}"/"${iso_filename:?}"

You now have all necessary files within ~/Downloads/arch-iso.

Verification of the downloaded files#

Check that the ISO file was downloaded completely and didn't abort mid-download, leaving you with an incomplete file:

if b2sum --check --ignore-missing b2sums.txt &> /dev/null; then
    echo 'SUCCESS: Download of Arch ISO successful. No download errors.'
else
    echo 'ERROR: ISO not correctly downloaded.'
    return 1
fi

Download the public OpenPGP key of the Arch maintainer (Pierre Schmitz) who signs the ISO files (conveniently through the Web Key Directory protocol) …

gpg --verbose \
    --locate-external-keys \
    --auto-key-locate clear,wkd \
    pierre@archlinux.org

… and use it to verify that the ISO file you downloaded is signed by him to detect if a mirror served you a malicious file:

expected_pgp_fingerprint='3E80CA1A8B89F69CBA57D98A76A5EF9054449A5C' &&

if gpg --verify --assert-signer "${expected_pgp_fingerprint:?}" \
    "${iso_filename:?}".sig "${iso_filename:?}" &> /dev/null; then
    echo 'SUCCESS: Nobody tampered with the ISO. Installer is safe to use.'
else
    echo 'WARNING: ISO has been tampered with.'
    return 1
fi

Almost done! Only one last (manual) check remains.

I've automated all the tedious checks that are necessary if you want to be responsible and avoid falling victim to a malicious man-in-the-middle. Whenever you're reading this tutorial, you should nevertheless make sure that the Arch maintainer who signs the installer ISOs still is Pierre Schmitz and that the fingerprint of his OpenPGP keypair hasn't changed since I wrote this tutorial. At the time of writing this guide, the fingerprint of Pierre's OpenPGP keypair is 3E80 CA1A 8B89 F69C BA57 D98A 76A5 EF90 5444 9A5C. Visit the Arch website and check whether it still says PGP fingerprint: 0x54449A5C (the last 8 digits of the long form of the OpenPGP key) on the linked webpage. If it still does, then the files you downloaded passed all security checks and you can rest assured that you really downloaded Arch Linux, not some state-sponsored spyware, and you can continue with the next step: flashing the ISO disk image you just downloaded to a thumbdrive.

Flashing the thumbdrive#

If your pre-existing machine uses macOS, the easiest method to flash an ISO disk image to a thumbdrive is Balena's Etcher (brew install balenaetcher). For Windows, it's Rufus.

In case you already use any Linux distribution, I suggest another method. Etcher is stuffed with trackers and telemetry. You can avoid having your personal data farmed by using some terminal commands I'll show you. Curiously, the best tool for the job is cat, not dd. Yes, not only can you use cat to flash ISO images to thumbdrives, it's also faster and less error-prone than dd.

First, find out the kernel name descriptor for your block device—that is, the sda in /dev/sda—of your thumbdrive (that needs to be plugged into your pre-existing machine at this point):

ls -l /dev/disk/by-id/usb-*

You probably see only one entry (but multiple lines) if there's only one USB device connected to your pre-existing machine.

SATA SSDs are listed as storage devices with alphabetically ordered letters, NVMe SSDs are listed in the format nvme0n1 with ordered numbers in place of 0. In case all your disks are NVMe SSDs, no SATA SSDs, your thumbdrive should have received the kernel name descriptor sda.

Ensure that no filesystem that might already be on your thumbdrive is mounted, by checking that the column MOUNTPOINTS doesn't show anything for your storage device:

lsblk --output NAME,MOUNTPOINTS | grep --extended-regexp '(MOUNTPOINTS|sd)'

In case a pre-existing filesystem is mounted, unmount it using the terminal command umount or the GUI of your current file manager.

If there's no mounted filesystem on your thumbdrive, use the following command to flash the Arch ISO to your thumbrive. Adjust the sda to the name of your thumbdrive as shown by the earlier command ls -l /dev/disk/by-id/usb-*. Omit the number that differentiates the partitions on the drive, use just the letter that differentiates the disks:

kernel_name_descriptor='sda' &&

sudo sh -c "cat archlinux-${latest_release_date:?}-x86_64.iso > /dev/${kernel_name_descriptor:?} && sync"

After that command completed, you may remove the thumbdrive from your pre-existing machine and plug it into the machine where you want to install Arch Linux.

Establishing remote access via SSH#

With your thumbdrive plugged into the machine that you want to bless with Arch Linux, you are now ready to boot that computer from the bootable thumbdrive. More convenient than having to type all commands yourself in a minimal environment without a web browser (and hardly being able to read the tiny default font) would be to be able to copy and paste the commands on the machine from which you're currently reading my website. For this purpose we're going to enable remote access via SSH on the computer where you want to install Arch.

To allow SSH access from another machine, you need to boot into the Arch ISO and set a password. By default, your user's password is the empty string and OpenSSH, by default, disallows empty passwords. You therefore need to reconfigure OpenSSH or simply set a password for the user root.

With the thumbdrive plugged into the "Arch machine", press the same key on your keyboard that you used to ensure that UEFI Secure Boot is disabled.

In the Arch installer environment#

The first step in the Arch installer environment, if you're not using an US keyboard layout, is to change the keymap to the one you're familiar with (for example, de, fr, et cetera). You don't want to mistype your password because the letters Z and Y are switched, in case you're German as I am. If you type on a US keyboard, skip this command:

loadkeys de

Now ensure the font is readable:

setfont ter-132b

Nothing should have happened because on new Arch ISOs this is already active by default. It didn't use to be, so the previous command was necessary to make the font big enough.

Now provide a password by typing it twice:

passwd

The provided password is valid only for the duration of this session. The next time you boot into the ISO or into your finished setup, you'll have to provide a password for root again.

Next, ensure your ISO environment is reachable from your pre-existing machine. I connect my fresh machine to my home LAN via ethernet, so I don't need to do anything. In case you insist on using Wi-Fi rather than ethernet, use the command iwctl. I won't explain it, you can find usage instructions on the internet.

Whether you connect via ethernet or Wi-Fi, check that the connection is up and running (and that you didn't pull out the ethernet cable when you plugged in the HDMI cable):

ip link

You should see the word UP in the color green.

Verify that you can access the internet from the ISO environment. You should see the output 0% packet loss:

ping -c 2 ping.archlinux.org |
    grep --only-matching --extended-regexp '[[:digit:]]+% packet loss'

Ensure that the SSH daemon is running.

systemctl status sshd

It should be running. If not, execute the following command. That shouldn't be required anymore though.

systemctl start sshd

If your "Arch machine" is in your LAN, you've finished this section. Continue with the rest of this section only if your "Arch machine" is outside your LAN, or if you've already finished the installation and intend to connect with the finished Arch installation rather than the ISO environment.

Optional steps in case your two machines are in different networks#

Find out the IP address of your Arch machine and note it down:

ip address show

Find out the names of the SSH host keys in the Arch environment:

ls -l /etc/ssh/ssh_host_*.pub

You should see /etc/ssh/ssh_host_ed25519_key.pub among others. If so, find out the fingerprint of that public SSH key and note it down. You're going to need it later. Otherwise adjust the filepath.

ssh-keygen -l -f /etc/ssh/ssh_host_ed25519_key.pub

On your pre-existing machine#

If your two machines are in the same network, then you don't need an IP address to connect with the ISO environment thanks to mDNS (Multicast DNS), a protocol for zero-configuration networking. The ISO environment is reachable under root@archiso.local.

From your pre-existing machine, connect with the Arch ISO environment using this command:

ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null root@archiso.local

Enter the password you configured earlier for the user root and you've established the SSH connection.

Installation#

To be continued after I found the time to install Iocaine. I don't intent to be "rewarded" for my effort by being ripped off by a LLM company scraping my website without consent.

Final words#

Feel free to contact me or follow me on social media. In any case, be well.