This guide is a detailed explanation of the installation process and things relating to it. This is not a guide that takes you step by step through the commands you need to run to install Arch Linux. If you want that take a look at the "Recommended guides" section below. This guide is meant to help you understand the commands you are running allowing you to install Arch Linux (or any DIY distro) the way **YOU** want or the way that best suits your needs. This guide should be used as a collection of useful links and ideas. A lot of information here can carry over to other operating systems installations but the focus of this guide is Arch Linux. If you are new to linux or never used it, what are you doing here? Go earn some _Tux exp. points™_by using [Fedora](https://getfedora.org/en/), its cutting edge, stable and better than Arch in a lot of areas. Linus Torvalds doesn't use Fedora without reason. This guide gets updated from time to time as the writer gains more _Tux exp. points™._
#### Arch Linux installation scripts
People have created Arch Linux installation scripts plenty of times. However [Arch Installer](https://github.com/archlinux/archinstall) is the only official automated script. This installer is optional. If the user desires to install Arch Linux manually they can still do so.
### Step-by-step guides
There isn't a single correct way to install Arch Linux, however, the most up-to-date and accurate is the official guide by the [Arch Linux wiki](https://wiki.archlinux.org/title/installation_guide). Remember none official guides tend to go out of date and become obsolete, some are linked here for reference and to show the various ways an installation can be configured.
* [It's FOSS (Gnome)](https://itsfoss.com/install-arch-linux/), [extra steps for KDE](https://itsfoss.com/install-kde-arch-linux/).
* [EF - Linux Made Simple](https://www.youtube.com/c/EFLinuxMadeSimple)
* [lbrame's Arch Linux tweaks](https://gist.github.com/lbrame/1678c00213c2bd069c0a59f8733e0ee6)
Pre-installation
----------------
* * *
### Requirements
This guide assumes you have a x86\_64 1 computer which has 2GB of RAM, 20GB of disk space 2, an internet connection, a USB with at least 2GB of storage 3.
1 Arch Linux only supports x86\_64 architecture, however a [fork](https://archlinuxarm.org/) of it exists for ARM CPUs.
2 Arch Linux can be installed on a smaller disk space and use less RAM but you probably (and should) use more.
3 The USB is not needed if you[Netboot](https://archlinux.org/releng/netboot/) into the live medium. An optical disc can also be used instead of a USB.
### Arch Linux ISO
The first thing we must do is to get the ISO file and USB device. Head over to [Arch Linux website](https://archlinux.org/download/) to download the official ISO using either a magnet link or a torrent file. To make use of the ISO file, we will need a bootable USB.
### Verifying the signature
Verifying the signature of the file is important to make sure the ISO you have is not compromised, malicious, or broken. The[Arch Linux wiki](https://wiki.archlinux.org/title/installation_guide#Verify_signature) covers this pretty well thus going over it would be redundant.
#### Etching software
Most guides recommend tools like [UNetBootin](https://unetbootin.github.io/), [Balena Etcher](https://www.balena.io/etcher/) or [Rufus](https://rufus.ie/en/) to etch an ISO file onto a USB device. These tools are great but they uses the entire USB (which could be 16GB or more) to etch a single distro in which the ISO might be 2GB large. Arch Linux's disk image takes up less than 1GB of space! Even if you aren't going to use all that space, It is time consuming and tedious to rerun the etching software every time you want to use a different operating system. If you are distro-hopping or would like to keep multiple operating systems (not just different distributions!) on a single USB, this guide recommends using a tool called [Ventoy](https://www.ventoy.net/en/index.html)1.
1 Ventoy is not the only program that can do this, [YUMI](https://www.pendrivelinux.com/yumi-multiboot-usb-creator/) (**Y**our **U**SB **M**ultiboot **I**nstaller) is another program that can be used.
### [](https://www.ventoy.net/en/index.html)Bootable USB
To make a bootable USB we will need to create it using [Ventoy](https://www.ventoy.net/en/index.html). Ventoy has both a GUI and a CLI clients therefore its perfect for any user. When you run Ventoy on your desired USB device, It will create 2 partitions. We only need to worry about one of these partitions, the empty one, this is were we will be putting our image files. After downloading the Arch Linux ISO (or any other ISO file), just move it to the empty Ventoy partition and we will be able to boot into it.
### Booting into the live medium
Reboot your machine and enter the BIOS/UEFI to disable "Secure Boot" if its enabled. Then boot into your USB device from the boot loader menu. Secure boot can be set up after the installation.
Installation
------------
* * *
### Partitioning
This is where things get interesting! Partitioning a disk is just dividing up your storage device into smaller chinks which may have different file systems. There is a plethora of partitioning tools you can use 1. The easiest non-GUI tool is "cfdisk". Some guides use "fdisk" which is more intimidating. There is multiple partitions you can make for many reasons. The simplest installation only requires 2 on a UEFI system, an EFI partition and a root partition. The EFI partition is needed to boot the system, it is your boot partition. The root partition is where everything else is stored. A BIOS system only need 1 root partition which contains everything.
1 Some partitioning tools are parted, fdisk, cfdisk, sfdisk, gdisk, cgdisk, and sgdisk. More can be found [here](https://wikiless.org/wiki/List_of_disk_partitioning_software).
#### Partition tables
A partition table describes how a disk is partitioned. There are 2 types of partition tables, the "Master Boot Record" (MBR) and "GUID Partition Table" (GPT). The GPT partitioning table is newer and is more feature rich than its predecessor. If you are installing an operating system you will want to use GPT unless you have a specific reason not to. GPT allows you to create more partitions and supports disks larger than 2TB.
#### Storage device naming scheme
When you are formatting your drives, you probably want to know which device is being used. In Linux, storage devices can be found in "/dev". HDD and USB storage devices are usually labeled as sdX. Where "X" is a lower case letter starting in alphabetical order (sda, sdb, sdc, etc.). each of these is a separate storage device.
An example list of storage devices names could look like this:
PATH NAME
/dev/sda sda <--HDD
/dev/sdb sdb <--SecondaryHDD
/dev/sdc sdc <--USBdrive
/dev/nvme0n1 nvme0n1 <--SSD
/dev/nvme0n2 nvme0n2 <--SecondarySSD
Number of partitions on a single disk is also taken into account. The number after the device name (sda**1**, nvme0n1**p1**)is the partition number.
An example output of the command "lsblk -o NAME,TYPE" is this:
$ lsblk -o NAME,TYPE
NAME TYPE
sda disk
├─sda1 part <--EFI-bootpartition
├─sda2 part <--Ext4-rootpartition
└─sda3 part <--swap-swappartition
sdb disk
└─sda1 part <--FAT32-extrastoragepartition
nvme0n1 disk
└─nvme0n1p1 part <--Ext4-homepartition
### Home partition
Creating more partitions allows you to better organize or even backup your data. A home partition will only hold the user(s) files (all of "/home"). The root partition will contain everything else (packages, operating system files, etc.).
### Swap
[Swap](https://wiki.archlinux.org/title/Swap) can be used to off load data from RAM, essentially giving you more ram at the cost of disk space using a process called paging. You can create either a swap file or a swap partition. Swap is also used for hibernation 1 of your system. Hibernation allows you to completely power off your computer which is why its more useful than normal sleep which keep the system on 2. Restoring from hibernation is slower compared to restoration from sleep. Having swap is recommended for lower end systems which may have less memory.
1 Hibernation is like entering sleep mode, however the data is stored in the swap partition/file. \`Normal\` sleep just keeps the data in RAM.
2 Sleep powers off all of the computers hardware (networking, display, etc.) with the exception of RAM. If RAM was powered off, nothing would be saved.
### File systems
After creating your partitions you have to format them. There is multiple[file system types](https://wiki.archlinux.org/title/File_systems). Different operating systems tend to use different file systems usually because these systems are proprietary. A variant of the [FAT](https://wikiless.org/wiki/File_Allocation_Table) file system, [FAT32](https://wikiless.org/wiki/File_Allocation_Table#FAT32), is widely used in storage devices of computers, cameras, embedded systems and game systems. Windows uses FAT32 for a boot partition and [NTFS](https://docs.microsoft.com/en-us/windows-server/storage/file-server/ntfs-overview) for its root partition. macOS uses [APFS](https://support.apple.com/en-ca/guide/disk-utility/dsku19ed921c/mac). Most guides tell you to format the EFI partition has FAT32 1 and the root partition as Ext4. Some guides use[BTRFS](https://btrfs.wiki.kernel.org/index.php/Main_Page) file system for the root partition, because it is faster than Ext4 and has more features, however it comes at the cost of [stability](https://btrfs.wiki.kernel.org/index.php/Status) 2. [](https://wiki.archlinux.org/title/ZFS)[XFS](https://wiki.archlinux.org/title/XFS) and [ZFS](https://wiki.archlinux.org/title/ZFS) can also be used instead of Ext4 for a root partition. If you created a swap partition you want to format it as such. If in doubt when choosing file system for your root or home partition, choose either BTRFS or Ext4.
1 If you are using a BIOS system you only have 1 partition which typically is formatted as Ext4.
2 Stability on BTRFS has not been an issue for a long time.
#### Encryption
If you plan on encrypting one or more partitions you should do so using the "cryptsetup" command. To setup encryption on a partition, format that partition as "LUKS" (either LUKS1 or LUKS2) using the command "cryptsetup --type luks2 luksFormat <pathtopartition>". Then you will be prompted to type a passphrase, make sure to memorize this passphrase because without it you will not be able to boot into your operating system 1. Before you can use the partition, you will need to create and form the virtual disk. To access the encrypted partition, type the command "cryptsetup open <pathtopartition><name>" (the example below uses "crypthome" as the name). Then you can mount the virtual drive and use it. The path of the virtual drive is "/dev/mapper/<name>".
A more detailed explanation of how to encrypt your drives can be found on the [Arch Linux wiki](https://wiki.archlinux.org/title/Dm-crypt).
1 You will be prompted to enter this passphrase every time you boot your system (assuming the partition will get mounted by the bootloader).
#### Unix/Linux file system structure
In a Unix/Linux system, everything is a file. If you wanted to know the specifications of your CPU, you can just look at the file in "/proc/cpuinfo". On a windows system, you would need to make an API call to get this information. In a Unix/Linux system, there is a single folder that contains everything. This folder is called root "/". Running processes can be found in "/proc" (notice that "proc" is inside "/"). [Linux Journey](https://linuxjourney.com/lesson/filesystem-hierarchy) explains the different directories well.
### Mounting
After partitioning and creating the needed file systems you need to [mount](https://man.archlinux.org/man/mount.8) them to write data to them. Mounting allows you to attach other partitions onto your root partition. For example, when you plug in a USB storage device into a Linux system the OS will automatically mount it to a specific directory such as "/run/media/<user'sname>". To install Arch Linux, you will need to manually mount the created partitions on to the live system to install the necessary programs. You would need to mount "/dev/<rootpartition>" on to "/mnt" to install the system programs and you will also need to mount "/dev/<EFIpartition>" on to "/mnt/boot" to be able to boot. The "/mnt" directory will become the new root directory once the installation is finished. Files located at "/mnt/var" in the live environment will be at "/var" on the new system.[](https://wikiless.org/wiki/Hard_disk_drive)
#### Mounting encrypted partition
If you encrypted your root partition you would need to mount "/dev/mapper/root" to "/mnt". If you created a separate home partition and is also encrypted you would need to mount it to its corresponding mounting point. each encrypted partition will need its own passphrase 1.
1 If you got an encrypted root and home partitions you will need to type 2 passphrase to actually use your system.
### Pacstrap
Pacstrap is a script which you will need to install the base system, Linux kernel 1, and the kernel's firmware. The pacstrap is essentially the "pacman" command but installs packages to a different root partition. The script can also be used to install programs into the new root partition. It is a good idea to install a text editor when you run this command because it will make life easier later.
1 There are different kernels officially supported by Arch Linux.
#### Linux kernels
There are 4 official variants of the Linux kernel. The "Stable kernel" is the main vanilla Linux kernel. The "Hardened kernel" is more security orientated and mitigates exploits better. The "Long term kernel" is aimed at providing long term support (LTS). The LTS kernel is better suited for servers and for older hardware. The "Zen kernel" is optimized for performance and speed. The actual linux kernel executable is located at "/boot/vmlinux" (assuming the vanilla kernel).
1 A list of kernels can be found [here](https://wiki.archlinux.org/title/Kernel).
#### Mandatory Access Control
A base Linux install usually defines restrictions to users based on what group they are in and what permissions a certain file has (i.e. [**D**iscretionary **A**ccess **C**ontrol](https://wikiless.org/wiki/Discretionary_Access_Control)). [**M**andatory**A**ccess **C**ontrol](https://wiki.archlinux.org/title/Mandatory_Access_Control) adds extra restrains to better improve security. Actions done in a system with MAC is checked against a set of rules and policies (which can not be changed by users) to allow or deny the action. There are different implementations of MAC for Linux systems, most popular being [**S**ecurity-**E**nhanced **L**inux (SELinux)](https://wiki.archlinux.org/title/SELinux). There are other implementations such as [AppArmor](https://wiki.archlinux.org/title/AppArmor) (which is used by default on Ubuntu and SUSE) and [TOMOYO](https://wiki.archlinux.org/title/TOMOYO_Linux).
##### SELinux
SELinux is [currently not officially supported](https://wiki.archlinux.org/title/SELinux#Current_status_in_Arch_Linux) but can be installed. SELinux works by replacing the DAC system and is used by RHEL by default. Using SELinux means a lot of packages, including the kernel, would need to be recompiled with SELinux support flags. Commonly used packages are recompiled with the needed flags and can be installed from the AUR.
### File system table
The new operating system will need to know where each partition is located and where to mount it. The command "genfstab" will **gen**erate a **f**ile **s**ystem **tab**le to define where those partitions mount.
### Configuration
This section is not necessary for the installation process 1, however some programs might not work properly without them. To configure the new system you will need to run the "arch-chroot" command on the new root partition "/mnt". [Chroot](https://wiki.archlinux.org/title/Chroot#Using_arch-chroot) is an important command to keep in mind in case the system breaks in the future. This command will **ch**ange the **root** user of the live system into the root user of the new system. Inside the chroot environment you can set up the timezone, locale and networking, but this can be done after installation. One thing you should do in the chroot environment is setting up the bootloader. You should give the new root user a password using the "passwd" command.
1 If you consider the bootloader unnecessary.
### Initial ramdisk
During the boot process the Linux kernel's modules need to be loaded. The initial ramdisk loads these before handing them over to the init system (systemd when using vanilla Arch Linux). The "mkinitcpio" 1command creates the initial ramdisk using the configuration file located at "/etc/mkinitcpio.conf". Executing "mkinitcpio" creates kernel images in your boot partition. If you plan on messing with boot process, having an understanding of the [initial ramdisk](https://wiki.archlinux.org/title/mkinitcpio) helps.
1 "mkinitcpio" is not the only program that can be used to create the initramfs image, others such as [dracut](https://wiki.archlinux.org/title/Dracut) and [booster](https://wiki.archlinux.org/title/Booster) can also be used. A list can be found [here](https://github.com/LaszloGombos/awesome-initramfs#projects).
#### Hooks
Hooks are extra scripts that extend what the initial ramdisk can do. For example, they allow the kernel to open encrypted partitions, resume from hibernation, allow useage of BTRFS partitions or access to file systems on LVM and more,
### Bootloader
Most guides use GRUB as the bootloader however you can use other bootloaders such as systemd-boot. A list of bootloaders can be found [here](https://wikiless.org/wiki/Comparison_of_boot_loaders). Inside the chroot environment you want to configure the bootloader because you can not boot into the operating system to configure it there (there no bootloader yet!). Setting up the bootloader on a UEFI system will need a package called "efibootmgr" and (obviously) your bootloader of choice. For a GRUB installation, you will want to create a directory inside"/boot" the name doesn't matter (in our example we will use "/boot/efi"). The following sections will assume you are using GRUB. GRUB configuration file is located at "/etc/default/grub" and after editing it you will need to run "grub-install" 1.
1 When running "grub-install" make sure to point it to the efi directory you created earlier.
When configuring the bootloader or the initial ramdisk it is recommended to use a [persistent block device naming](https://wiki.archlinux.org/title/Persistent_block_device_naming) scheme like the **U**niversal **U**nique **Id**entifier (UUID) of the partition rather than using the device name.
The bootloader will need to know which partition is encrypted to it can open it properly. You need to tell GRUB what partition is encrypted using "cryptdevice". You will also need to allow GRUB to boot from a LUKS device.
If you have multiple operating systems you will need to run "os-prober" so GRUB can detect other OSes. Also you should enable "GRUB\_DISABLE\_OS\_PROBER" in your GRUB config.
#### Hibernation
To be able to restore from hibernating you will need to add "resume" and point it to your swap partition/file. You should also add it to "GRUB\_CMDLINE\_LINUX\_DEFAULT".
Plymouth is not part of the installation process however it looks good. To use plymouth you will need to add the necessary strings to the "mkinitcpio.conf" and to the bootloader (GRUB in this example). "plymouth" needs to be after "base" and "udev".
MODULES=(i915) <forIntel
MODULES=(amdgpu) <--forAMD
HOOKS=(plymouth encrypt)
The following command line entries need to be added for a smooth experience. The "splash" entry is absolutely needed for plymouth (or any other graphical boot process).
Plymouth is a fantastic program, [here](https://github.com/adi1090x/plymouth-themes) is a list of some themes some of which are ported from android.
#### Secure Boot
Secure Boot adds a layer of security to the boot process by checking the cryptographic signature of the kernel and bootloader. Arch Linux's installation does not support Secure Boot; however, it can be setup easily using [sbctl](https://wiki.archlinux.org/title/Unified_Extensible_Firmware_Interface/Secure_Boot). To use you would need to enroll your own keys into the UEFI and sign the kernel and the bootloader EFI executable binaries.
### Init systems
The most used init system is systemd however many people consider it bloated. Arch Linux uses systemd. Other init systems are openrc, runit, s6, sysvinit, dinit, sinit, epoch, upstart and GNU Shepherd. If you do not wish to use systemd but still want a DIY distribution then consider using an alternative operating system such as Artix Linux, Void Linux, Gentoo Linux, Linux from scratch (LFS) or even a BSD distro. Swapping out systemd on Arch Linux will guarantee detrimental damage to the operating system.
IDK where to squeeze this in so I'm putting it [here](https://wiki.archlinux.org/title/Arch_boot_process).
Post-installation
-----------------
* * *
### Desktop environments
There are many desktop environments (DEs) for Linux and BSD systems. Most commonly used are Gnome and KDE. A DE is just collection of packages which setup the GUI and install some user applications 1 that share a common graphical framework 2 to reduce bloat and graphical inconsistency. All DEs install with a window manager however you can install a window manager without installing a DE. A list of all DEs can be found [here](https://wikiless.org/wiki/Desktop_environment) and for officially supported DEs on Arch Linux [here](https://wiki.archlinux.org/title/desktop_environment#Officially_supported). The Arch Linux wiki has a desktop environment [comparison page](https://wiki.archlinux.org/title/Comparison_of_desktop_environments).
1 The applications installed vary with each DE but usually include an application center, terminal, file manager, settings application, screenshot utility, text editor, web browser, office suite, and similar applications.
2 The most used Libraries are [GTK](https://www.gtk.org/), [QT](https://www.qt.io/) however others exist such as [Enlightenment](https://www.enlightenment.org/about-efl.md). More libraries can be found [here](https://wikiless.org/wiki/List_of_platform-independent_GUI_libraries).
### Window managers
Window managers (WMs) are programs that work with the window server 1 to produce a graphical interface. Window managers control the behavior and appearance of the windows running inside it. There are 3 types of window managers, floating/stacking, tiling, and dynamic. Floating window managers are what Windows and macOS use. In a floating WM, the windows may overlap other windows. Floating window managers require the mouse to resize and move the windows. Tiling WM is where windows are automatically organized into tiles to maximize the screen real estate. These tiles do not over lap. Tiling window managers are minimal in nature and do not depend on the mouse to move and resize windows. Dynamic window managers are a combination of Floating and tiling WMs. A list of window managers can be found [here](https://wiki.archlinux.org/title/Window_manager#Dynamic_window_managers).
1 The window server usually is either X.Org or Wayland. Other window servers can be found [here](https://wikiless.org/wiki/Windowing_system#SurfaceFlinger).
### Display managers
The graphical interface where you login to a specific user is the display manager 1 (DM). From it you can choose which desktop environment or window manager to use. DE tend to ship their own DMs for example, Gnome uses the Gnome Display Manager (GDM) and KDE uses Simple Desktop Display Manager (SDDM). DM are usually graphical but CLI/TUI DMs exist. The [Arch Linux wiki](https://wiki.archlinux.org/title/Display_manager#List_of_display_managers) has a list of display managers you can use.
1 Also referred to as the login/session manager.
### Users
Limiting access to certain commands is needed for good security. You can create a new user account using the command "useradd -g <name>", the "-g" flag is for creating a home directory for that user. You can assign a password to that user using the "passwd" command. Add a user to a group using the "usermod" command. To allow user accounts to elevate their privileges to root, add them to the "wheel" group 1.
1 The "wheel" group isn't necessary for privilege escalation but its widely used. Other groups or manually giving a user privilege also works. More information about the "wheel" group [here](https://thecustomizewindows.com/2014/03/what-is-wheel-group-in-unix-unix-like-os/).
#### Privilege escalation
To change the privilege of a user or group you edit the file "/etc/sudoers" using the command "visudo" 1. Other commands commands like "sudo" exists such as "su" and "doas". "su" is the predecessor of "sudo". "doas" is alot simpler than "sudo" also it is significantly smaller in size. The "doas" config is alot nicer and less intimidating than "sudo"'s. I can not recommend "doas" for beginners because "makepkg" fails (requires a patch to work with "doas"). If don't plan on using "makepkg" then replace sudo!
1 [Why use "visudo" instead of manually editing the file directly?](#INTERNAL_LINK#/post/null)
#### Permissions
Files and directories have specific permissions based on certain criteria. Using a command like "ls" 1 we can see the permissions of a file or directory:
$ ls -l
drwxr-xr-x linux linux 4.0 KB Wed Mar 16 14:15:14 2022 Documents
\-rw-r--r-- linux linux 143 B Thu Nov 11 17:30:07 2021 file.txt
^^^ ^^^ ^^^
│ | |
| | Group.
│ |
| Owner of file/directory.
|
These are the permissions.
To better understand this we will split the sting into 4 smaller strings:
╭───────────────── Tells us if entry is a directory or a file.
│
│ ╭────────────── Tells us the permission of the file's owner. (Think "Can the owner of this file read/write/execute it?")
│ │
│ │ ╭────────── Tells us the permission of users in the assigned group.
│ │ │
│ │ │ ╭────── Tells us the permission of every other user.
│ │ │ │
d rwx r-x r-x
The letter "r" means read, "w" means write, and "x" means execute. The lack of a letter "-" means no permission is given.
\- rwx r-x r--
│ │ │
│ │ ╰───── Any other user (not the owner or in the group) can only read the file.
│ │
│ │
│ │
│ ╰─────────── Users in the group can only read and execute the file.
│
│
│
╰───────────────── The owner of this file can read, write and execute it.
Keep in mind that the root user has read, write and execute permissions to everything. This is one of the reasons why using root for everything is dangerous.
1 The command "namei" can be used to follow the path of a file/directory and list permissions of its parent directories.
### Arch User Repository
There are 2 main repositories to install packages from, the [official stable repo](https://archlinux.org/packages/) and the [AUR](https://aur.archlinux.org/packages). The AUR is a collection of user submitted packages while the official repo are selected and verified by the Arch Linux developers and repo maintainers. Since the AUR is based on user submissions, you should inspect the "PKGBUILD" of a program before installing it (in case it is malicious or broken). The are more repositories you can download software from but often it is unneeded and may break package dependencies. List of [official](https://wiki.archlinux.org/title/Official_repositories) and [unofficial](https://wiki.archlinux.org/title/Unofficial_user_repositories#arch4edu) repositories. Anyone can create a repository, instructions on how to do so can be found [here](https://wiki.archlinux.org/title/Pacman/Tips_and_tricks#Custom_local_repository).
#### AUR helpers
Using an AUR helper is not needed but makes installing packages easier. A list of them can be found [here](https://wiki.archlinux.org/title/AUR_helpers). To manually install an AUR package you should download it from the AUR site and then compile it's "makepkg" after inspecting the "PKGBUILD". A list of AUR helpers can be found on the [Arch Linux wiki](https://wiki.archlinux.org/title/AUR_helpers) 1.
1 I have contributed the one of the AUR helpers, [Aura](https://github.com/fosskers/aura)!
description: 'A list of some awesome commandline tools.'
pubDate: 'May 31 2022'
---
Learning how to use the terminal is a side effect I gained after switching to GNU/Linux. It is absolutely not necessary to know how to use it, but it makes you more productive (and look cooler?). These are some command line applications I use:
* \`lf\` (**l**ist **f**iles) is a terminal file manager. I use \`lf\` with \`lfimg\` which allows you to preview the text files, render images/gifs and shows properties of binary files.
* [Neovim](https://neovim.io)
* Text editor. If you are too lazy to customize it with plugins you should use [LunarVim](https://lunarvim.org). I use \`neovim\` whenever I need to make a small change to a file, I tend to use "VS Code" for actual heavy-duty programming.
* [Glow](https://github.com/charmbracelet/glow)
* Fast and simple markdown renderer. Definitely worth checking out [charm.sh](https://charm.sh/).
* [Cmus](https://cmus.github.io)
* fast and feature rich music player. Honestly I prefer \`cmus\` over any music player GUI or non-GUI.
* [Doas](https://github.com/Duncaen/OpenDoas)
* \`sudo\` but less bloated and better security due to less surface attack. There is only one problem with \`doas\` and that is it currently does not work with \`makepkg\`.
* [Jdupes](https://github.com/jbruchon/jdupes)
* A powerful duplicate file finder and an enhanced fork of \`fdupes\`.
* I have \`rm\` aliased to this command ([the documentation says not to](https://github.com/andreafrancia/trash-cli#can-i-alias-rm-to-trash-put)). This can be the difference between life and death. \`rm -rf\` is a dangerous command to run. Its safer to trash the file/folder than permanently deleting it.
* [Chezmoi](https://www.chezmoi.io)
* Manages dotfiles and configurations of various programs (like the ones in this list).
* [Mosh](https://mosh.org)
* Alternative \`ssh\` which maintains connection after changing networks, running commands using it is faster than regular \`ssh\`. Use \`screen\` with \`mosh\` to maintain a connection after closing the client.
* [Pwgen](https://sourceforge.net/projects/pwgen)
* generates passwords or random strings.
* [Bat](https://github.com/sharkdp/bat)
* \`cat\` but with syntax highlighting and integration with \`git\`. I have \`bat --paging=never\` aliased to this command.
* [Zoxide](https://github.com/ajeetdsouza/zoxide)
* \`cd\` but remembers previous directories.
* [Lsd](https://github.com/Peltoche/lsd)
* \`ls\` but deluxe. Its a rewrite of \`ls\` in rust. I have \`ls\` aliased to this command.
* [Tokei](https://github.com/XAMPPRocky/tokei)
* Counts number of files, code written, comments, blank spaces, and lines of code used within a directory.
* Power consumption monitor and power saving tool.
* [Speedometer](https://excess.org/speedometer)
* Shows network usage. This program has a lot of configuration options!
* [Lolcat](https://github.com/busyloop/lolcat)
* Makes output of last command rainbow.
* [Pywal](https://github.com/dylanaraps/pywal)
* Generates color schemes based of a provided images. I use \`pywal\` in a script to automatically choose a random image (or I can manually choose one) to use as my wallpaper and theme my desktop to match its colors.
[Gemini](https://gemini.circumlunar.space/) is a HTTP/HTTPS alternative protocol. Other protocols like Gemini are [Gopher](https://wikiless.org/wiki/Gopher_(protocol)?lang=en) and [Finger](https://wikiless.org/wiki/Finger_%28protocol%29?lang=en), all of which render webpages. The HTTP/HTTPS sites are extremely bloated with JavaScript, user tracking, and generally slower than what it can and should be. Gemini and other alternative protocols want to being back a lightweight text-based internet back! If there is demand for it (or if I feel like it) I will make a Gopher and Finger sites.
I have launched a Gemini site which you can access using this link: [gemini://arrayinamatrix.xyz/](gemini://arrayinamatrix.xyz/)
This link will take you nowhere if you don't have a browser/client that is compatible with the Gemini protocol. I recommend the [Kristall browser](https://github.com/MasterQ32/kristall/) which can access not only Gemini sites but also other web-pages using HTTP, HTTPS, Gopher and Finger. Like always, there are [other clients](https://gemini.circumlunar.space/clients.html) you can use. You can visit sites using Gemini using a proxy like this [one](https://gemproxy.koyu.space/).
Screenshots of the Kristall client:
[](/kristall-gemini.png)
Kristall displaying my Gemini site.
[](/kristall-https.png)
Kristall displaying my HTTPS site.
I have Mirrored my [website](https://arrayinamatrix.xyz/) and the [Arch Linux wiki](https://wiki.archlinux.org/) on Gemini:
My site: [gemini://arrayinamatrix.xyz/](gemini://arrayinamatrix.xyz/)
description: 'How I setup adblock on all my devices at home.'
pubDate: 'Jun 30 2022'
---
### Table of Contents
* [Choosing an OS](#mcetoc_1gk98jdno10a)
* [Background](#mcetoc_1gk98jdno10b)
* [Setting up](#mcetoc_1gk98jdno10c)
* [Mapping IPs](#mcetoc_1gk98jdno10d)
* [Switching to Void Linux](#mcetoc_1gk98jdno10e)
I am writing this because I am waiting for Gentoo (specifically Portage) to finish compiling and installing packages (It is taking forever!). This isn't a guide, I'm just documenting what I'm doing. I recently _acquired_ a Raspberry π 3 B and want to setup a network-wide ad-block on my home network.
### Choosing an OS
First thing to do was choose an operating system to run on the device. I used Gentoo for a bit but now I'm running [Void Linux](#mcetoc_1gk98jdno10e). I have pretty much no experience with Gentoo or any \*BSD OS. So I [Startpage](https://www.startpage.com/)\-ed a little and settled on choosing between Gentoo or FreeBSD. If you read the first line of this blog, you already know what I went with. I installed Gentoo not in a traditional way (compiling kernel from source with [USE flags](https://wiki.gentoo.org/wiki/Handbook:AMD64/Working/USE), based) but I used an install script (cringe). I used Sakaki's [gentoo-on-rpi-64bit](https://github.com/sakaki-/gentoo-on-rpi-64bit) (unmaintained) script but after the installation I found the (maintained-ish) [fork](https://github.com/GenPi64/gentoo-on-rpi-64bit), which is what I should have been using.
### Background
The easiest way to setup an ad-block is to get a list of ad/tracker domains and just forward them to 0.0.0.0 (nullifying the request) in `/etc/hosts`([like this](https://github.com/StevenBlack/hosts)) but this is not complicated enough for me (and isn't network-wide), so what I have chosen to do is install [Pi-hole](https://pi-hole.net/), which happens to also uses the previously mentioned list. Pi-hole's list of supported OSes does not include Void Linux either Gentoo or FreeBSD so why did I chose to run an advanced-level operating system which isn't officially support to do such a mundane task? This question is left as an exercise for the reader.
### Setting up
Now, we do the usual stuff when installing a new system, syncing repositories, updating preinstalled packages (not like there were many to begin with), installing docker and docker compose, installing a good text editor (i.e. neovim), changing the shell and themeing it, setting up ssh keys, etc. The Pi-hole project provides a docker image which can be used on any OS. I used the [project's quick start yaml script](https://github.com/pi-hole/docker-pi-hole/#quick-start) and created an executable shell script with `docker compose -f docker-compose.yml up -d` to easily update Pi-hole. I appended the domains and their respective IP addresses to the file `custom.list`located in `/etc/pihole` inside the docker container (on the host system, the folder `etc-pihole`relative to the working directory).
### Mapping IPs
On my home internet, I have to type the local IP address of my server to actually access it which is inconvenient due to numerous reasons. Pi-hole can be used as a DNS server which can be used to map my domains to my server using the local IP. Mapping domain names to IP address can be done using the hosts file but editing this for every device is inconvenient and tedious. Using pi-hole, services which rely on a domain name or a SSL certificate (e.g. [Matrix](https://arrayinamatrix.xyz/index/apps/matrix/)) work without a VPN or proxy on the same network it is hosted on.
_Client and server without DNS server:_
client ---> server (local/public IP address)
_Client and server with DNS server:_
client ---> Pi-hole DNS server ---> server (domain name)
### Switching to Void Linux
After using the π with Gentoo for a couple months, I have decided to switch the operating system to Void Linux. Firstly, using prebuilt binaries is against the philosophy of using a source-based OS. Compiling packages on the π takes longer than I would like. Void Linux has better support for ARM CPUs, they even have [builds](https://voidlinux.org/download/) specific for the Raspberry π. Installing on the Void on the π is far easier and quicker than Gentoo. I used Void's rpi-aarch64 glibc live image. I would use the musl build for better security (i.e. less attack surface) among other things but some software may be [incomparable](https://docs.voidlinux.org/installation/musl.html#incompatible-software) (it probably does not matter in my use case, might actually be better to use musl but I do not want to run into any surprises).
Hello readers, this is the first article on my new site! I'll be showcasing some of its features here! The source code for it can be found [here](https://git.inamatrix.xyz/array-in-a-matrix/bloginamatrix.xyz).
## Technologies
The original blog site was created using [Publii](https://getpublii.com/). It is a nice application if you want to create a site without any coding. The reason I am not going to be using it anymore is because I want my blog site to reflect me better. Publii isn't flexible enough for me to do that.
### Framework
This website is built using the [Astro](https://astro.build/) framework with several plugins. This site is my first experience with it so it may not be the best or most unique looking. Surprisingly, it was not as hard as I expected it to be. I initially wanted to build this site using the Nim programming language but it's web frameworks can not compete with JavaScript or TypeScript just yet (and I do not want to write bindings). The site is not completely written by me from scratch as I used Astro's blog template.
### Editor
I really like Markdown and I've been using it everywhere from writing notes, documentation[^1] or even in my messages with others ~~assuming the chat app supports it like [Matrix](https://matrix.org/)~~. My favorite Markdown editor right now is [Joplin](https://joplinapp.org/), which is FOSS and cross-platform. It supports the extended Markdown syntax and has many community made [plugins](#plugins).
[^1]: I'm lying about documentation. I use [VSCodium](https://vscodium.com/) instead.
### Plugins
The plugins are the most exciting part of this whole thing I think. You can find the plugins for Joplin and Astro [here](https://github.com/joplin/plugins/) and [here](https://astro.build/integrations/) respectively.
> "***Actually***, Astro calls them **integrations** not *plugins*." - 🤓
A lot of heavy lifting is done using [Unified](https://github.com/unifiedjs) and the plugins they maintain. I heavily recommend checking the project out as it opens the doors to so many possibilities!
### Rendered
#### Basic and Extended Markdown
You have seen some throughout the article but did you know <mark>this text is highlighted</mark>? Did you know that <sup>this is superscripted</sup> and <sub>this is subscripted</sub>? <sub><sup>What about both</sup></sub>?
To do:
- [ ] Do this thing
- [ ] Do that thing
- [x] procrastinate
> There is a list! - 💩
+ Days of the Week
+ Weeknotend
1. Monday
2. Tuesday
3. Wednesday
4. Thursday
5. Friday
- Weekend
- Saturday
- Sunday
Extended Markdown brings some much needed elements.
Can't wait to put food on the table.
| Fruit | Sandwich | Cheese |
| :--------- | :--------: | ------: |
| 🥝 | 🥙 | 🧀 |
| 🍑 | 🌭 | 🧀 |
| 🍉 | 🏖️🧙 | 🧀 |
This document is actually MDX not pure Markdown.
MDX can be used for UI component stuff like JSX. You can import MDX into other MDX or into `.astro` files and the reverse works too!
Here is a code block:
```c hello.c
#include<stdio.h>
int main(void) {
printf("Hello World!\n");
return 0;
}
```
#### KaTeX
Markdown renders that can not render mathematical equations suck because you are then forced to either create an image or write the equation using special unicodes.
Time-dependent Schrödinger equation:
$$
i \hbar \frac{\partial}{\partial t} \ket{\Psi(t)} = \hat H \ket{\Psi(t)}
There are 2 types of modifications that can be done on a phone, hardware and software. I have jailbroken my phone on many occasions because I like being able to customize it and add functionality to make IOS a more usable operating system. Hardware mods can extend the life of your device or turn it into a explosive.
Hardware
--------
I have done 2 hardware modifications so far, LED in the Apple logo and LEDs in the speaker grill, both of which were done on an iPhone 7 Plus which I dragged through software and hardware (I skateboard) hell. I have also repaired the displays and buttons of a couple IOS devices (yes, this isn't relevant, I don't care). Other mods exist which actually make the device better like [replacing the Lightning port with a USB-C port](https://kenp.io/iphone_usbc_mod_part_1/), [adding duel SIM support](https://youtu.be/MgK4-RB35do) and expanding the device's storage as seen [here](https://youtu.be/rHP-OPXK2ig) and [here](https://youtu.be/oPHZodRrkt0).
### RGB Apple Logo
The RGB Apple logo mod was the more successful mod out of the two I've done, which is also the first. Installing it went flawlessly and I didn't notice any extra power drain using it. The LED Apple logo is touch sensitive which switches between different color animations and can be used to turn the LED off. Below are all of the states the LED can be in, 7 color cycles and the off state.
I wouldn't consider this mod a success. I damaged the ribbon cable which connected the power/side and volume buttons, which then I had to get a replacement part and somewhat fixed (the power button is super mushy and very unresponsive as the part does not properly fit). I also partially damaged the speaker LEDs so only one grill had working lights. I didn't take any presentable pictures of this mod (pain) and a couple weeks after installing it, I dropped the phone and killed off the speaker, mic and broke the display. [The mod looks like this](https://youtu.be/07bTt0BTi-U). This mod considerably affects the amount of power the mic gets (keep in mind I was using this mod along side the light up Apple logo and never tested it alone) which can, if on a call for example, make the other person unable to hear you. The lights are very visible in the dark (that's a thing light emitting things do) but not so bright outside in the day time which is understandable.
array-in-a-matrix