Chapter 2 - Installing Arch Linux #

Some Background #

⬤◯◯◯◯◯◯◯◯◯

Unlike Windows or Mac which are primarily differentiated by versions (Windows XP, Vista, 7, 10…), Linux has two important things to look out for:

• The distribution name (Arch, Ubuntu, Mint, Debian, etc.)
• Kernel version number (5.18 last time this page was updated)

So, what do each of these mean?

Well, Linux is actually just the name of the underlying ‘core’ of the system, known as the kernel, as such, there are literally thousands of Linux variations or ‘distributions’. Some of the well known variants include Ubuntu, Fedora, OpenSuse, and Arch (No disrespect to the other distros out there!). Each of these has a different target audience, with some meant for servers, some meant for casual users as an alternative to Windows, others as work station for hard core computing. They also ship with different software pre-installed to be accessed after the first boot.

The other differentiating factor is the version of the Linux Kernel that they use. Some chose to use an older, battle hardened kernel that is known to be very, very stable, others chose a nice middle ground, while yet others continuously release an update to the newest available kernel. There are pros and cons to each model and each has its place; however, the distro I’m going to have you install, Arch, uses the (almost) the newest available, updating very regularly. Arch has a reputation as one of the hardest distros to work with, but also one of the most cutting edge, fun to tinker around in, and best documented.

Arch is what’s known as a rolling release distribution, which means it gets the bleeding edge features and the newest kernel pretty much as fast as possible, though really the biggest thing that makes Arch special is how bare bones it is out of the box, shipping with basically no pre-installed software. In fact, when you first start it up the only thing you’ll see is a screen to type and run commands, and that’s where we’re going to start.

Arch Linux Logo from archlinux.org

For most distros like Ubuntu or OpenSuse (feel free to look these up, this page isn’t going anywhere) there’s a nice graphical, point and click installer which helps you install the system and somewhat mitigates potential risk of killing your original OS (Mac/Win) or losing data; however, the goal of this guide is to learn. Arch’s install process, entirely by typing commands in this terminal is hard, but that difficulty leads to a deeper understanding and respect for the system as a whole

When we’re done you’ll have a system that has exactly what you need and nothing you don’t. You won’t find weird forcibly installed software like Win 10’s Candy Crush App here, and your system will only do exactly what you tell it. Of course, this implies you know how to speak it’s language and tell it what you want. Thankfully with some practice you’ll get used to running Arch and you’ll wonder why you ever dealt with other systems to begin with.

However,

Arch Linux expects you to fully understand your system

TLDR; STFW:

You shouldn't have to R all TFMs.

The Boring Intro Part Of The Manual That You Should Still Actually Read #

⬤⬤◯◯◯◯◯◯◯◯

We’ll be following along with the Official Arch Linux Installation Guide, so you’ll see this page has a lot of quote boxes:

Okay, that’s a lot, so let’s break it down. By “live system” this means we’re going to be booting into an operating system from our installation media - for almost all situatations, this is a flash drive. This OS is “live” in that it is a true, full, Linux operating system. It’s just running directly off the flash drive. In this case, this live system is really just used so that we can install Linux to a more permanent drive. So, rather ironically, we’ll be using Linux to install Linux.

The “with accessibility options” page is if you need something like a screen reader or if you have a braille display. I have no experiance helping with these things. More relevant to most readers, the Category:Installation process page has a bunch of very important steps that aren’t on this page. Most importantly, there’s a page about Setting up a Dual Boot system with Windows - which I’ll be going through here. I won’t be covering the process if you have a Mac, but there is a page for that: Mac Installation. Note that Apple’s newer computers with their own processors aren’t supported. are still a massive pain in the ass to get working.

Alright, let’s buzz over to the FAQ and see the relevant bits:

All of these are very good points. The fact of the matter is Arch does take time and know how to maintain. You’re standing on the edge of a cliff here. You have to be dedicated and willing to learn. You also have to have hardware that actually works with Arch (which should be the case with most anything but Chromebooks and newer Apple hardware). The one that I think is hard for users starting out with Arch is the last point “you are happy with your current OS.” - I’m going to take a bet and say you don’t really fully understand why you’d be unhappy, let alone un happy with things enough to justify all this work. All I can say is trust me and you’ll see.

There’s also that Help:Reading (which, yes, sounds like it really wants to insult your intelligence) but it is helpful. The most notable thing here is

# mkinitcpio -p linux

$ makepkg -s

which will be exteremly relevant later.

There are other things of relevance in the FAQ, but I think a lot of it won’t mean much at this point, so let’s move on.

A little self referential here, but good advice- the ArchWiki is really awesome and if you need help it’s a good idea to just search the Wiki for the topic you’re stuck on. This also mentions “man pages”. This is where I have to go down a bit of a tangent.

To install Linux, you’ll have to use a lot of commands. For example running ls from the terminal will list your files, while cd can be used to change what folder you’re working with. But these commands have other, more complex uses which you can read about from the terminal itself by running man ls or man cd. Generally, if you want a manual for any command, you can just put the word man before it.

The latter two recommendations are ways to get live help from real people. IRC is a really, really old chat platform that is still heavily used by tech-heads, but can be a bit difficult to get setup. The forums are what you expect, but I’ve noticed they’re not all that welcoming of new users. There’s not many good options though, so if you do need more help, there’s really either the Arch Linux Telegram Chat or you’ll have to figure out how to use IRC.

In English:

• Your computer needs to not be a new mac or a chromebook
• Your system needs to have better hardware than something from 2001
• You’ll need some room on your computer’s storage to actually install Arch
• You’ll need an internet connection

Finally, before we get do actually doing the thing, you might want to read Arch Community Ethos by Xyne. To some extent, the existance of this page goes against the community ethos, but the install guide is also needlessly dense, as stated above.

Actually Starting To Do Something - Downloading #

⬤⬤⬤◯◯◯◯◯◯◯

Alright, so you need to actually download the live OS installer “image” (it’s called an image for historical reasons - same for .iso, it’s for CDs, but you can put the file onto a flash drive). If you go to that download page you’ll see an ton of options and some mention of using something called dd to get the image onto a flash drive. Ignore almost everything. The only thing we need to worry about is the section labeled BitTorrent Download (recommended)

This has the advantage of verifying the PGP signarute for us, which is what that extra line about the GunPG signature line is telling us about. TL;DR of PGP (and GPG, which is an implimention of PGP, as confusing as that is) is that it can be used to confirm that a file is actually what it says it is and is from who it says it’s from. This makes sure your download isn’t corrupted and that it actually came from the people that it claims to be from.

So, to download this then you’ll need a Torrent client.

Torrenting is type of download that runs over distributed peer to peer connections, this means you’re directly downloading the file from multiple people rather than from one large server. For projects like Arch this is important as they don’t really have the cash to put up to host centralized servers. Popular programs for downloading torrents on Windows include uTorrent, qBittorrent, and Deluge. I personally use Deluge on Windows, so it’s what I’ll recommend if you don’t already use something else. If you’re on a Mac, here’s a link to qBittorrent.

Regardless, once you have the torrent client installed you should be able to back to that download page and click the magnet link - which should open up whatever torrent client you installed and prompt you to start the Download.

Note, when the download completes, your torrent client will continue to serve the file to other people looking to download it to using your internet connection. Generally, this is a good thing to do, but you’ll want to turn it off, at least temporarily, as we move forward. If you don’t, some of the next steps may complain at you saying the file is open/in use. This also might end up eating all of your bandwidth or be undesirable if you’re on a metered internet connection.

☕ The download shouldn’t take long, but this depends on your connection. Feel free to go get a drink or take a break while you wait.

Once that’s done downloading your torrent client should automatically confirm the image by using PGP, but as this is a good learning opportunity let’s do a manual double check as well.

1

certutil -hashfile archlinux-20xx.xx.xx-x86_64.iso sha256

gpg: Signature made 1/1/2023 9:49:49 AM Central Standard Time
gpg:                using EDDSA key 3E80CA1A8B89F69CBA57D98A76A5EF9054449A5C
gpg: Good signature from "Pierre Schmitz " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 3E80 CA1A 8B89 F69C BA57  D98A 76A5 EF90 5444 9A5C

1

MacBook:~ username$

gpg: Signature made 1/1/2023 9:49:49 AM Central Standard Time
gpg:                using EDDSA key 3E80CA1A8B89F69CBA57D98A76A5EF9054449A5C
gpg: Good signature from "Pierre Schmitz " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 3E80 CA1A 8B89 F69C BA57  D98A 76A5 EF90 5444 9A5C

Now, we finally have file that we can 100% trust. Realistically, this level of scruntiny isn’t really necessary, but I wanted you do go through it and understand it at least once for reasons you’ll understand later.

Making The Installer #

⬤⬤⬤⬤◯◯◯◯◯◯

Okay, so we have the OS, how do you install the damn thing? Well, get ready for a fun time. The first thing you’ll need is a flash drive with nothing on it you care about, as it’s going to be reformated, which will wipe any data on it. To install an OS you have to create ‘bootable media’ this used to be done with a CD, though mostly it’s done with flash drives now. You’ll actually be putting the OS on the flash drive and then using that to put it on your hard drive / SSD.

Let’s not get ahead of ourselves though, we need room to put the new operating system in! Thankfully Linux is small- really small. Even 50Gb should be plenty for the OS, all your programs, and tons of room to spare for data, but I typically recommend at least 100GB, and since we’ll be installing a lot of development tools, it makes sense to do this right to begin with.

Before we move on, I think it’s good to sight see a bit:

If you followed along, you should have already prepared the installation image on a flash drive, but you could have put it on a CD or use PXE. You’re probably thinking “WTF is PXE?” Well, it’s a way to send a new operating system image to a computer over the network. This is mostly used by really big sever farms/datacenters, but you should still know it exists, even if you’re unlikely to ever use it.

Booting Up The Live Environment #

⬤⬤⬤⬤⬤◯◯◯◯◯

☠☠☠
Seriously, backup your shit. I've done this countless times and have still managed to accidentally wipe a drive. There's a non-0 chance you're about to completely murder your windows install, It shouldn't happen, but it can. This is a necssary evil to learn, and I assure you'll be happy you've done all this, but this next bit is actual hell for people. I'm sorry it gets so bad so early. I promise it's worth it, okay? The next section requires a lot of reboots and has steps where you can't have this guide open on the computer you're working on, so you may want to have a spare system (or this page open on your phone) next to you to follow these insturctions on and Google if anything goes wrong.
☠☠☠

Okay, so we’re finally ready to enter Arch Linux’s installation environment, which as previously mentioned, is actually itself Arch Linux…

… or we would be, if Microsoft didn’t try to shove Secure Boot mess down our throats. This is the most in-flux part of this guide, as it’s a bit unclear what the implications of Windows 11 requiring Secure Boot will be. This mess is in part described in This article (nerdschalk.com) but the TL;DR is Microsoft is really doing their best to turn a “security feature” into an Antitrust lawsuit.

Assuming your system is new enough to be using secure boot, you have two options

1. Follow that disable Secure Boot link and do what’s necessary to get that done
2. You can go down the rabbit hole of Making the installer work with secure boot. To say this is a massive pain in the ass would be an understatment.
   • In theory the five step in this stack exchange answer should be enough to get it working, at least enough to boot the installation image. You’ll still need to work a bit harder later to work around things.

If your system is older then congrats(?) you don’t need to worry about this.

For now, I’m going to assume option 1. as upon asking others, you can still disable Secure Boot in Windows 11 and everything seems to be working fine. If this changes, please let me know, and I’ll update this guide.

With secure boot disabled (or the modified installation image) you should, finally, be able to reboot your computer into the installation image. Mash the whatever key is required to get to the boot menu on your system (F11,Delete,F12,F7, and F2 are common). Do this and select the flash drive from the list.

You might have a system that makes the time in the UEFI loading screen to short to be able to get to a boot menu. As recommended on the disabling secure boot page, you can also do Settings > Update & Security > Recovery > Advanced startup (Restart now) > Troubleshoot > Advanced options > UEFI Firmware settings and hopefully you can find a setting to change to give yourself some time on load to change boot device, but you’ll almost certainly see a boot order or boot override option. Chance things as necessary so that the next boot will be off of the flash drive.

Until this point I’ve been avoiding going over the difference between UEFI and BIOS, but now we really need to cover it. For most newer systems (~2015ish) the computer will be using UEFI, while if it’s older it’s probably using BIOS. The Binary Input Output System or Unified Extensible Firmware Interface both more-or-less serve the same purpose: When you turn the system on, they initialize the firmware of all of the components inside your system and sort of serve as the initial system to get everything working before handing things off to the boot loader, which then boots up the operating system. So, the process goes:

BIOS/UEFI → Boot loader→ OS (Windows/Linux/Mac)

From our perspective, the biggest difference is really just that UEFI is newer and a bit easier to work with, but there are a lot of interesting changes I encourage you to read up on later. We do still need to know which we’re using though. Assuming you had to deal with Secure Boot, you’re using UEFI. If you didn’t, you’re probably using BIOS. Fortunately, we can now check by running a command. So, go ahead and get your keyboard layout set so you can comfortably type, and then run the command under “Verify the boot mode” →

Connecting to the Internet #

⬤⬤⬤⬤⬤⬤◯◯◯◯

# ls /usr/share/kbd/keymaps/**/*.map.gz

# loadkeys de-latin1

# ls /sys/firmware/efi/efivars

Take note of if you’re using BIOS or UEFI, because it will be relevant later. For now, we need to get you connected to the internet.

Okay, so, there’s a lot here, let’s just step back and go over this. The first step here is just making sure the system detected your hardware and has a driver for connecting to the network. Linux has most network drivers you’d ever want baked in, so that should just work. In this case, when running ip link you should see either something like enp6s0 or wlan0. In this case, the former is a wired interface while the latter is for Wi-Fi.

If this didn’t work and there’s only a device called lo, there are options, but they’re a bit complicated.

If you can, getting things working by using a wired connection is much, much easier. If you had a wired connection attached when you booted into the installation environment, it should just be working. in which case you can r

Then, congrats, you’re good to move on.

# rfkill list
0: phy0: Wireless LAN
	Soft blocked: yes
	Hard blocked: yes

# rfkill unblock wifi

ath10k_pci 0000:01:00.0: board_file api 2 bmi_id N/A crc 32 318825bf
ath10k_pci 0000:01:00.0: htt-ver 3.60 wmi-op 4 htt-op 3 cal otp max-sta 32 raw 0 hwcrypto 1
ath: EEPROM regdomain: 0x5f
ath: EEPROM indicates we should expect a direct regpair map
ath: invalid regulator domain/country code 0x5f
ath: invalid EEPROM contents
ath10k_pci 0000:01:00.0: failed to initialize regulatory: -22
ath10k_pci 0000:01:00.0: could not register to mac80211 (-22)

Again, run ping archlinux.ong and if after a few seconds you see something like

64 bytes from archlinux.org (░░.░░░.░░░.░░░): icmp_seq=░ ttl=░░ time=░░░ms

Then you’re good to move on.

Press Ctrl+C to stop ping

While it may seem like an odd time to do so, now that you’re connected to the internet, go ahead and get the time of your system fixed. This uses Network Time Protocol to get the time, which is why we had to do it after connecting to the internet.

# timedatectl set-ntp true

With that done, we’re onto the fun bit.

The Part Where You can Really Fuck Up #

⬤⬤⬤⬤⬤⬤⬤◯◯◯

☠☠☠
Seriously, backup your shit. Last Warning.
☠☠☠

This is the part where we need to partition the disks. Remember before how I told you needed to make free space on your hard drive in the Windows Disk Management utility? This is where that comes into play.

# fdisk -l

I’ve written this assuming you’re installing alongside Windows. If it’s a mac, it should be more-or-less the same, but mentally substitute NTFS for HFS+ - I’ll explain what these are in a second.

Okay, first things first, fdisk -l is going to give you a ton of information that you probably don’t know how to read, so let’s just use lsblk , and while it’s a lot to type, running

lsblk --output NAME,MODEL,TRAN,SIZE,FSTYPE,MOUNTPOINT will give us a lot of useful info in a digestable format. On a typical system with one or maybe two disks, you should be looking for the drive with multiple partitions where one of them is a small vfat partition, one is a large NTFS partition, and there’s a big unformulated block that you free’d up earlier. There might also be an extra, probably NTFS, recovery partition for Windows.

Now, that you have the output of this command for yourself as reference, let’s talk about what’s going on here:

A tangent about File Systems & Partition Table Schemes #

Okay, here we have to go off into the weeds to understand something real quick - partition tables and file systems.

To begin with, let’s look at what good ol’ Wikipedia has to say:

Well, uh, that was a lot of words that didn’t say much, we have to go deeper. MBR? That sounds familiar click.

Okay, so, the Partition Table is basically an index of partitions - divided sections of your disk - and what file system each one uses. Old computers used to use a MBR partition table, new computers use GPT.

What about these File Systems then, what’s that? Let’s ask the all knowing Wikipedia again:

Wow, uh, that was strangely readable for tech stuff, right? There is one bit of context missing here though - there’s more than one way to sort your files - similarly, different file systems have been made over time.

The two you’re likely familiar with are NTFS and FAT32. NTFS is the one Windows uses by default for your operating system and storage drives, FAT32 is what most flash drives use. You may have ran into limitations of FAT32 before, most notably that you can’t store a file larger than 4GB - making moving a large video or ZIP archive an issue.

But, why? If NTFS doesn’t have this problem, why would anything use NTFS? Moreover, what does Apple use HFS+ and Linux use EXT4 or BTRFS (commonly, there’s many others).

Well, the answer is complicated. Some of it is politics with patents, some of it is backwards compatibility, some of it is for speed vs stability, some of it for supporting different physical media (spinning platters vs solid state vs tape)

While there’s literally hundreds of file systems in existence, only some are used enough to be worth knowing about. Here’s the extreme TLDR of each:

• NTFS -The only decent file system that Windows supports. Stable, does the job. Annoying to mount on Apple devices, but can accessed on most systems.
• FAT32, exFAT - Old, shit, but it works on everything easily. The default for SD cards and flash drives.
• EXT3, EXT4 - Common on Linux. Stable, does the job. Very annoying to mount on Windows.
• HFS, HFS+, APFS - 🍎, Think Different.
• ZFS - Need to store an ever living fuck load of data across a boat load of drives? ZFS will do that, make sure some drives can fail without loosing anything, let you speed it up by using an SSD or RAM for cache, and do some crazy voodoo to ensure data never gets corrupted + snapshotting (file history) + automaticly using spare disks if one fails + per-user limits… Awesome, right? Yep. And also a true pain in the ass to setup, a RAM hog, etc. Basically, ZFS is perfect for a file server and not worth the pain & RAM use at all in a normal setup.
• BTRFS - Somewhere between ZFS and EXT4. A sane option for most personal Linux setups. Has had broken RAID 5 for a long time, don’t use that and you’re fine.
• F2FS - I have a NEED, A NEED FOR SPEED … and data corruption… Shit. For SSDs, the new kid on the block, and ready to eat your data if you have to hard shutdown. Only use this if you know what you’re doing. But, it do zoom.

For setting up your system to dual boot Linux and Windows, you’ll need to use NTFS to read your existing data, FAT for the boot partition (more on that soon), and I’ll be showing setting up the Linux root using BTRFS, but using EXT4 is also a fine choice.

There are a few weird not-true-filesystems you should be aware of too:

• CIFS/SAMBA - Used to mount network shared storarge
• SWAP - Swap isn’t actuallllly a file system, it’s actually more like explicitly saying you don’t want a filesystem here. This is used for storage when you’re out of RAM or when something in RAM hasn’t been used in while it gets swapped to, well, swap. You can’t directly put files here.
• TMPFS - Almost the inverse of Swap, TMPFS is a special file system for storing data directly in RAM. This makes it stupidly fast. It’s also volatile, data written to TMPFS will be lost when your computer reboots.

You may want to dive into the Arch Wiki page on File systems.

An aside about size #

If you bought a computer and were told it has a 1TB SSD, it does, but your computer may tell you it’s only 931GB. What gives!?

Well, the problem is we have two ways of specifying size, Megabytes and Mebibytes, and often the “wrong” term is used. I say “wrong” as it’s very rare anybody uses the Mebi version at all, and instead Mega is used for both. But, okay, what’s the difference?

In SI units, we have prefixes that you should known killo=1000, mega=100000, Gig=1000000000, etc. So a Kilobyte should be 1000 bytes, right? Well, by definition yes, but often people will mean Kibibytes where it’s actually 1024 Bytes. Why 1024?

Computers work in base-2 (binary) and so if we do 1 << 10, an operation that literally means take 1 (in binary, which is also 1 in decimal) and move it over 10 places, to put 10 zeros behind it, we get the number, in binary, 10000000000, now, to read a binary number you start at the right most digit and that’s your 1’s place (just like decimal) but then the 2nd digit is your 2’s, the 3rd your 4’s, and so on. Finally, you’ll hit the 11’th digit which is your 1024’s place. so this number, with only the 11th digit being 1, is equal to 1024 in decimal.

Basically, 1024 is a much more convenient number to work with for the computer than 1000, which in binary would be 1111101000.

Finally, we can work our way up and the problem get’s worse. A megabyte is a thousand killobytes, but a mebibyte is 1024 kibibytes. So now the difference is 1000*1000 vs 1024*1024, then repeat up to Terabyte. That’s why your numbers may not match.

Fortunately, this rarely matters as if you’re doing something where you have to think about the difference it’ll usually be with other numbers that set your constraints and the difference won’t matter. For example, we’re about to format your drive for Linux, but you’ll be constrained by the remaining size for each partition and for the few small ones we need to make being off by the difference of the binary or decimal version just won’t matter. Still, good to know.

FUSE, Encryption, LVM, RAID, WTFFFF‽? #

FUSE #

Okay, I swear we’ll get to the actual formatting soon, but there are a few more things you need to know about first.

First, FUSE,

You’re eyes probably just glazed over reading that. I don’t blame you. Basically, Linux will normally assume only the root (admin) user can create a files system as doing so is something that typically happens at the kernel (operating system core) level. FUSE, well, fuses fyle systems on to kernel interfaces that are already there so that a non-admin user can mount things.

Why is this helpful?

Well, the most obvious is flash drives. It’d sort suck if you had to provide a password and do low level management every time you want to read a flash drive. FUSE let’s you not do that.

But that’s not all. With extra software on top,

• It’ll let you mount a .iso so you can peruse it’s contents without actually writing it to flashdrive/CD.
• It’ll let you mount network shares via SSH (the normal tool used to remotely manage Linux devices)
• It’ll let you mount NTFS file systems with an older, more stable, and faster implementation of the file system driver
• It’ll let you mount your GoggleDrive as a local folder for easier use

Among other things.

There’s a catch to all of this though. FUSE is generally a bit slow. The NTFS situation as mentioned above is an outlier here, but there are some negatives to its convenience.

Encryption #

I’m sure you know what Encryption is broadly, and generally that it’s a good thing for security. But I want to point out a few things before we jump on the “Let’s encrypt all the things!” train.

• Encryption makes your computer do a bit more work on every read and write, making it a hair slower and use more battery.

• Encryption makes recovering your system if something has gone wrong more difficult

• Encryption can be a pain to setup

• Encryption only protects your files when the computer is off *

  * -ish. It is possible to setup encryption that locks most of your files if the computer goes to sleep or locks after you’ve been away for a while, but this doesn’t lock everything.

It’s up to you to decide if it’s worth it to you. If you do want full system encryption, I do recommend making an extra, unencrypted FAT32 partition with a singe .txt file with details to contact you if you loose your computer - or, better, put an “IF FOUND RETURN TO” sticker on it.

I’ll lead you though setting up home directory encryption on this page, as I think it’s a happy middle ground.

LVM #

I swear we’ll be getting back to the install for real in a second, the last thing related to drive formatting you should know about is Logical Volume Management. To Wikipedia we go!

Plus, not on that page, it can be used to cache frequently used content on a faster disk. This is awesome for making an old HDD feel snappy on a system with a big HDD(s) and a small SSD.

So, basically, it’s a layer in between the physical device (SSD, HDD, whatever) and the file systems to make it so you can resize and mess with them while the system is still running, use encryption in a sane way, and easily add or remove drives.

There is a big ol’ fuck you here: Using LVM makes it more annoying to access the Linux files from Windows. So while in nearly any other situation I’d say you should use it, if you’re setting up dual boot, don’t. Since that’s the setup I’m assuming you’re going for here, I will not be showing LVM setup on this page.

If you’re not setting up a dual boot system and you’re up to the challenge, these two pages are very nice:

Arch Wiki - LVM & Arch Wiki - Installing on LVM

Be very, very, very sure you know the disk/partition you’re about to nuke #

Okay, so, we from here on this guide has a lot of commands that are not exactly what you should type, as the exact command will vary depending on your hardware. The most important variable here is the disk you’re planning to install to. If you get this wrong, you’ll eat Windows. Just be careful and you’ll be okay.

Doing the Actual Partitioning & mkfs #

# fdisk /dev/the_disk_to_be_partitioned

Okay, what this is saying is that when we got to make our partitions - assuming we’re on a not-ancient computer - We’ll need 3 partitions. One for booting, one for swap, and one for everything else. This is where things start to get weird in this guide, as, if you’re dual booting with Windows, we can commandeer the Windows EFI system partition (the boot partition) to make our lives easier. First though, we need to check we can actually do that.

Above, what probably feels like forever ago with all this reading, you should have ran

lsblk --output NAME,MODEL,TRAN,SIZE,FSTYPE,MOUNTPOINT

and you should get output at least sorta-kinda similar to this:

NAME        MODEL                           TRAN     SIZE FSTYPE   MOUNTPOINT
loop0                                              702.1M squashfs /run/archiso/airootfs
sda         Cruzer Blade                    usb     29.3G iso9660       
├─sda1                                               801M iso9960
└─sda2                                                15M vfat
nvme1n1     CT4000P3SSD8                    nvme     3.6T        
├─nvme1n1p1                                 nvme     300M vfat
├─nvme1n1p2                                 nvme     128M        
├─nvme1n1p3                                 nvme     3.6T ntfs
└─nvme1n1p4                                 nvme     714M ntfs   
nvme0n1     SPCC M.2 PCIe SSD               nvme   953.9G        

Now, there’s bound to be some differences. Here, I have a separate, unused disk to install Linux onto - nvme0n1 down there with no file system, no partitions, and nearly a whole terabyte free to use. If you instead had to shrink Windows to make room for the install, you’ll probably have something closer to this:

NAME        MODEL                           TRAN     SIZE FSTYPE   MOUNTPOINT
loop0                                              702.1M squashfs /run/archiso/airootfs
sda         Cruzer Blade                    usb     29.3G iso9660       
├─sda1                                               801M iso9960
└─sda2                                                15M vfat
nvme1n1     CT4000P3SSD8                    nvme     3.6T        
├─nvme0n1p1                                 nvme     300M vfat
├─nvme0n1p2                                 nvme     128M        
├─nvme0n1p3                                 nvme     1.6T ntfs
├─nvme0n1p4                                 nvme     714M ntfs   
└─nvme0n1p5                                 nvme      2TB 

Where instead of having a second disk, you have a large (hopefully 128GB+) partition with no file system on it. Either is fine. Regardless, what you need to note is the name of disk or partition. In the first example that’s nvme0n1, as the entire disk is free for use to use as windows is on an entirely different drive. In the second example it’s nvme0n1p5 as we’re going to be splitting up and using that partition, but you’ll also still need to note the drive, which in that case is also nvme0n1.

In either case, we can avoid the need to make a new boot partition because that vfat partition on the same drive that has the NTFS partitions is a boot partition. It’s the one Windows uses and the one we’re going to steal.

So, let’s do it. In both examples above - the made-space and fresh drive - the drive name we’re targeting is /dev/nvme0n1 so, we can run cfdisk /dev/nvme0n1 . That c on the start of the command the guide recommends will give us a nicer interface.

(note, this is a screenshot of a drive with Windows without free space, as I can’t easily screenshot from a system mid-install)

What you should do is first make 10GB SWAP partition. To do this, arrow-key down to the big block of free space on your drive (or, if it’s a fresh disk, it’s the only thing there) and use the left and right arrows to highlight “new” at the bottom. Press enter. It’ll ask you for a size. It should default to all the remaining size. We don’t want that. Backspace it and write 10G for 10 gigabytes. This is a good amount of swap on most systems.

Alright, that should have made the partition, but it’ll say “Linux Filesystem” on the right. We want this to be swap. With it highlighted, go over to “Type” and press enter. That’ll bring up a big dialog, select “Linux Swap”.

Now, arrow down to your remaining free space and hit New. Leave it with all your remaining space. Press enter. This new partition should say Linux Filesystem, it should be at least 100GB in size, and conveniently, if we hover over it should say at the bottom Filesystem: BTRFS - it’s making a BTRFS file system on the partition for us. Sweet.

Okay, that’s done, we can now use the arrow keys to select “Write” and press enter. It’ll warn you this is where shit can hit the fan. Type “yes” to say you want to do it, to which it should respond with “The partition table has been altered.”

Congrats, you made the partitions and formatted the drive. Easy, right? arrow over to quit, and press the up arrow a few times until the previously entered lsblk --output NAME,MODEL,TRAN,SIZE,FSTYPE,MOUNTPOINT command shows up, and press enter. You should now see your new partitions - one with the FSTYPE btrfs and one swap. Hell yeah!

# mkfs.ext4 /dev/root_partition

# mkswap /dev/swap_partition

# mkfs.fat -F 32 /dev/efi_system_partition

AYYYY, we already did this. We already have our swap and BTRFS partitions. (We’re using BTRFS, but the above shows using EXT4 for the same use - it doesn’t matter much). That big warning in yellow is exactly the step we’re not doing because we’re using Windows EFI partition.

Mounting #

# mount /dev/root_partition /mnt

# mount --mkdir /dev/efi_system_partition /mnt/boot

# swapon /dev/swap_partition

Okay, when we ran lsblk to confirm we have our partitions, we can see what the partition name is. For me, on the fresh disk, this gave me

NAME        MODEL                           TRAN     SIZE FSTYPE   MOUNTPOINT
loop0                                              702.1M squashfs /run/archiso/airootfs
sda         Cruzer Blade                    usb     29.3G iso9660       
├─sda1                                               801M iso9960
└─sda2                                                15M vfat
nvme1n1     CT4000P3SSD8                    nvme     3.6T        
├─nvme1n1p1                                 nvme     300M vfat
├─nvme1n1p2                                 nvme     128M        
├─nvme1n1p3                                 nvme     3.6T ntfs
└─nvme1n1p4                                 nvme     714M ntfs   
nvme0n1     SPCC M.2 PCIe SSD               nvme   953.9G   
├─nvme1n1p1                                 nvme     10GB swap
└─nvme1n1p2                                 nvme   943.9G btrfs  

So to mount my btrfs partition I’m going to run mount /dev/nvme1n1p2 /mnt. This will make the storage we made accessible at the folder /mnt. Finally. We could actually go store a file there now if we wanted. We don’t want to, but we could.

Okay, now we need to mount the boot partition, the place we’re going to store the information Linux needs to start itself. Like I said, we’re commandeering the Windows spot for this. Fortunately both can live along side eachother fine. You’re looking for the moderately sized vfat partition on the same drive as some NTFS partitions. Here, that’s nvme1n1p1.

We want to mount this inside of the existing /mnt This may seem weird, but it’s like saying if you go to this folder inside of this file system, you’re actually going to a different file system all together. This is really common in Linux and admittedly a bit weird to think about.

Anyway, we need to put this boot partition at /mnt/boot, so with this example I’ll run mount --mkdir /dev/nvme1n1p1 /mnt/boot. The --mkdir part of that makes the folder named “boot” on the btrfs partition to mount this in. If that doesn’t make sense don’t worry about it to much.

Finally, we’ll enable our swap, you know the drill. Find the partition the swap is on - above it’s nvme1n1p1 so I’ll run swapon /dev/nvme1n1p1.

Congrats, Now you can actually install Arch. #

⬤⬤⬤⬤⬤⬤⬤⬤◯◯

Technically you should check this and make sure it’s sane. In reality, if you have internet connection - which we made sure you did above - it should be. Doing this manually is a pain, so I’ll just assume it’s fine.

# pacstrap /mnt base linux linux-firmware

FINALLY. This is the fun command. It’s called pacstrap because it uses pacman (the system package-manager) to pull the system up by it’s bootstraps - We’re finally getting this thing rockin`.

So, lets do it. run pacstrap /mnt base base-devel linux linux-firmware linux-headers. That’ll take a hot minute and fill you screen with many lines of text. When it’s done you’ll have a very minimal (read: Mostly useless) Linux install done. Unfortunately, you can’t even boot into it yet as you haven’t even installed a boot loader.

Getting The Basics Configured #

⬤⬤⬤⬤⬤⬤⬤⬤⬤◯

# genfstab -U /mnt >> /mnt/etc/fstab

Do the thing ↑. We’ll need to edit it later, but for now that command alone should do the trick.

In short, this is generating (gen) your filesystem (fs) tabulation (tab) file which is what Linux looks for on startup to figure out what filesystems to load, where they’re at, and how to load them.

# arch-chroot /mnt

Run that command ↑.

What this is doing is changing our root (chroot = change root) to our new install. This means when we edit files from here on out we’re working on the system we’ll actually be using instead of the one that booted off the flash drive.

# ln -sf /usr/share/zoneinfo/Region/City /etc/localtime

# hwclock --systohc

To see your options you can type ln -sf /usr/share/zoneinfo/ and press tab. Type the region and the slash, then press tab again. Obviously the city doesn’t have to be where you live, it just has to be in the same time zone.

The second command synchronizes the computer’s hardware clock.

This does have an annoying side effect. When you boot back to Windows, the time will be wrong. You can fix that by next time your in windows, opening an admin command prompt and running

reg add "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\TimeZoneInformation" /v RealTimeIsUniversal /d 1 /t REG_DWORD /f

# locale-gen

LANG=en_US.UTF-8

KEYMAP=de-latin1

Ironically, the edit part of this is the awkward part as you don’t actually have a text editor yet. So, lets go install one.

Because your system has just been installed, we know it’s list of packages that are available is up to date, so we can run pacman -S nano to -Synchonize the nano package to our system using pacman. nano is the name of a basic, terminal-user-interface (TUI) text editor. You’ll be asked if you want to install it. Press ‘y’ and ’enter’.

Now, we can edit that file. Run nano /etc/locale.gen. For pretty much any of my readers your LANG should be en_US.UTF-8 so scroll down in the file that opened with your arrow keys until you find that and then remove the # before it. Then, to save the change, do Ctrl+o (the ^ character in the usage guide at the bottom means Ctrl). Then do Ctrl+x to exit.

Then make the /etc/locale.conf file, to do this run nano /etc/locale.conf and fill it with what you need, LANG=en_US.UTF-8 as in the example above is probably applicable to most readers. Save it and exit nano again.

Finally, run locale-gen.

myhostname

Okay, so, right now you have access to the network in your chroot because the networking as setup from the flash-drive’s live system is still active, but if were to reboot (and you had a bootloader, which you don’t yet) you wouldn’t have networking because you have no networking stack setup to provide it!

Let’s fix that.

First, you should do what the guide says and set your host name. This is the name other computers on the network can use to identify your computer. You could make it say “bobs-laptop” but you can also have fun and make it more-or-less whatever you want. Don’t use spaces or weird characters though.

Like before, you just need to nano /etc/hostname. Type the name you want. Save. Close.

Okay, now we need to actually set up the networking software. I recommend using NetworkManager. We can install that with pacman -S networkmanager

We’ll set it up in full later.

# passwd

This is effectively the admin password. Do not forget this, or you’re pretty much fucked.

While we’re at it, let’s set up the very start of a user account, as using root all the time is very unsafe. To do so run:

1

useradd -m -G wheel mycrappyusername

followed by,

1

passwd mycrappyusername

(I recommend using the same password you used for root)

Now, we need to make it easy to use your account as an admin account via the sudo command (super user do).

run

1

EDITOR=nano visudo

then find the line that says

1

# %wheel ALL=(ALL) ALL

and remove the ‘#’

As an explanation, the ‘#’ is turning that line in that file into a comment. In programming it’s common practice to use comments to disable sections of code so say we had a program:

1
2
3

for i in range(5)
    #print(i)
    print(i/2)

the # before print(i) is preventing it from actually executing so the output of this would be {1/2,1,3/2,2,5/2} instead of {1,1/2,2,1,3,3/2,4,2,5/2,5}

This gets to be all kinds of fun, because this is where some computers just say “Nah, fuck you.” And you’ll have to either debug from hell to figure out why something isn’t working or you’ll have to try another option.

If you’re computer is UEFI (so, not ancient) systemd-boot has historically work quite well for me, but because I want to be 100% sure if you’re following this guide that your computer will actually work, I’m going to recommend the ol’ reliable: Grub.

To do so, first actually install the packages pacman -S grub efibootmgr os-prober

We need to set grub to detect the Windows install. nano /etc/default/grub and remove the # on the line with GRUB_DISABLE_OS_PROBER=false

then actually install grub with

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

In it’s output it should say os-prober will be executed… somewhere.

Finally Removing The Flash Drive #

⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤

[TODO] make sure the UEFI loads the new bootloader

When you boot into the new system it will ask you for a username and password. The username is and password is whatever you set before. When you type the password it won’t look like you’re entering anything, don’t worry, it’s still registering the input. Just type it and press enter.

Now, we can load up networking. Run systemctl enable NetworkManager and systemctl start NetworkManager. Enabling makes it start up on each boot, starting it starts it now for this boot. You won’t need to run these again. Now, we can actually configure the network - if you’re wired in, it should just work, but if you’re on WiFi just run nmuti → “Activate a connection” → find your network, enter your password. Keep pressing escape to get back to the terminal when done.

Run ping archlinux.org and if after a few seconds you see something like

64 bytes from archlinux.org (░░.░░░.░░░.░░░): icmp_seq=░ ttl=░░ time=░░░ms

Then you’re good to go. Press Ctrl+c to stop ping.

But Wait? This is worse than when we started? #

⬢⬡⬡⬡⬡⬡⬡⬡⬡⬡

Yep, as it is right now you’ll have a terminal that pretty much does nothing. Great! Time to go grab all the things you want.

Dual boot? Getting access to the other disk #

Before we do that though, if you’re dual booting, you’ll want to set up your system so that it automatically mounts your other OS’s disk. The easiest way to do this is to.

1. If it’s not already, make sure you have ntfs-3g installed. Just do a pacman -S ntfs-3g.

2. Run lsblk -o name,mountpoint,label,size,fstype,uuid

3. Figure out which Partition has Windows on it. If you have multiple disks, this may be a bit awkward. Here, for example is mine:

   nvme1n1                                            953.9G          
   ├─nvme1n1p1 /boot                                      2G vfat     EAEC-8D86
   ├─nvme1n1p2                                           16M          
   ├─nvme1n1p3                                        951.2G ntfs     D00CEBCB0CEBAB24
   └─nvme1n1p4                                          715M ntfs     DA1E14C51E149C97
   nvme0n1                                            953.9G          
   ├─nvme0n1p1                                            1G vfat     96EE-30CD
   └─nvme0n1p2 /                                      952.8G ext4     629cedc3-e5bf-4496-a75b-78d6d1c30d88
   

   What you should see is one partition that has a mount point of /boot (nvme1n1p1, in my case) and one that has a mountpoint of just / (nvme0n1p2 in my case). Assuming nothing else weird about your setup, (no extra drives, etc.) you’re looking for a large (probably 250G+) ntfs partition that has no mount point. The only thing matching that above is nvme1n1p3. Note, your disks may start with “sd_” instead of “nvme_”

   Let’s see if that’s the right partition

4. Run mount /dev/[partition name] /mnt/win (for me, this would be mount /dev/nvme1n1p3 /mnt/win)

5. Run cd /mnt/win then ls -a . You should see all the folders you’d expect to see at the base of a C drive, “Users”, “Windows”, “Program Files”, etc.

   If you don’t - don’t panic. Do you see anything other than . ..? Do you recognize the folders? It’s possible you have multiple big partitions - maybe when your in Windows you also have another disk (probably D:/) - this might be that. This is good! It means we now know the partition with some of your data on it. Note this down somewhere - like sda3 has data and start from 1. again, pick another big NTFS partition, but when you go to mount change the path to /mnt/win[number you increment], and go from there.

   If you don’t see anything other than . .. it’s likely nothing got mounted at all. Re-run the big lsblk command and see if the partition shows up as mounted - see how this has the /mnt/win next to it now?

   ├─nvme1n1p3 /mnt/win                               951.2G ntfs     D00CEBCB0CEBAB24
   

   If /mnt/win is next to none of them, then the mount didn’t even work. Start from 1. If you still can’t get anywhere, ask around for some help.

6. Okay, so your disk is mounted and you have access to your files, but you really don’t want to do that every time you boot. Let’s add the partition(s) (multiple, if you have a data disk) to our FSTAB. Run nano /etc/fstab (with sudo, if you’ve jumped ahead and made a user) and add the line:

   UUID=[Your disks UUID] /mnt/win      ntfs-3g defaults,nofail,noatime,uid=1000,umask=0011 0 0
   

   For example, for mine, this would be:

   UUID=D00CEBCB0CEBAB24 /mnt/win      ntfs-3g defaults,nofail,noatime,uid=1000,umask=0011 0 0
   

   Now, if you reboot, your disk should automatically be mounted to /mnt/win.

   As a brief explanation. ntfs-3g sets what NTFS driver to use. ntfs3 instead should in theory be much faster, but it’s not super stable at the time of writing. As for the other flags:

   • defaults just sets sane mounting options for most things based on filesystem (NTFS, in this case) type
   • nofail sets it so that if it can’t mount the Windows partition, Linux doesn’t say “Nope!” and drop you into a “recovery shell”.
   • noatime sets it not to store access times. There’s a not-insignificant performance impact in doing so, so may as well turn it off.
   • uid=1000,umask=0011 - set’s it so that files are the users (well, when you make one) which should be of id 1000 and that all files are set to be able to be read, written, or executed. This is bad for security, but as your computer is probably single user, it’s fine.
   • The 0 0 at the end The first one should always be 0 as it’s for marking if the disk should be backed up using an old back up system nobody should use, and the second if a system should be checked for file system checking, and in what order. If it’s an NTFS disk and you dual boot, set it to 0. Your root / partition should be set to 1, if you care, you can set the others (if you have any) to 2, but, like, FS checking (fsck) is usually one of those things you’ll know if you need to do, so as long as the system boots, fuck it.

Setting up System-y Stuff (Logs, Background tasks, etc.) #

⬢⬢⬡⬡⬡⬡⬡⬡⬡⬡

Installing and Removing Software #

⬢⬢⬢⬡⬡⬡⬡⬡⬡⬡

Making your mouse serve a purpose again #

⬢⬢⬢⬢⬡⬡⬡⬡⬡⬡

Most mere mortals will prefer working in a graphical environment instead of the terminal for literally everything (though it is possible to do some crazy things so you can browse the web comfortably from one). So, that means we’ll need to grab display drivers corosponding to your graphics card (AMD, Nvidia, or Intel), pick a desktop environment and/or window manager (How everything looks and feels), and set up the Display Manager (What mostly serves as a login screen).

If you’re wanting to dive into something very strange but very cool, you might give Arcan a shot too. Just be warned, you’ll probably have to compile it from source!

If you’re feeling particularly weird, you might want to try ly too.

Mouse and Keyboard Configuration #

⬢⬢⬢⬢⬢⬡⬡⬡⬡⬡

Making your computer not drink power and run like ass #

⬢⬢⬢⬢⬢⬢⬡⬡⬡⬡

Audio would be nice #

⬢⬢⬢⬢⬢⬢⬢⬡⬡⬡

Networking-y Stuff #

⬢⬢⬢⬢⬢⬢⬢⬢⬡⬡

Making things look pretty #

⬢⬢⬢⬢⬢⬢⬢⬢⬢⬡

Back to the Terminal #

⬢⬢⬢⬢⬢⬢⬢⬢⬢⬢