Dual Boot Arch Linux: A Comprehensive Installation Guide

Dual Boot Arch Linux: A Comprehensive Installation Guide

Arch Linux, renowned for its flexibility and customization, offers a unique computing experience. However, its installation process is notoriously challenging. This guide provides a detailed walkthrough for dual-booting Arch Linux alongside an existing operating system, ensuring a smooth transition and a functional system.

Prerequisites

Before diving into the installation, ensure you have the following:

  • A computer with an existing operating system (e.g., Windows, macOS, or another Linux distribution).
  • Arch Linux ISO image: Download the latest ISO from the official Arch Linux website (https://archlinux.org/download/).
  • A USB drive (at least 2GB) to create a bootable installation medium.
  • Internet connection: Required for downloading packages during the installation.
  • Basic knowledge of Linux commands: Familiarity with the command line is essential.
  • Partitioning tool: GParted (recommended, available on most live Linux distributions) or a similar tool.
  • BIOS/UEFI access: You’ll need to access your BIOS/UEFI settings to change the boot order.
  • Time and Patience: The installation can take several hours, so allocate sufficient time.

Step 1: Preparing the Installation Medium

The first step is to create a bootable USB drive using the downloaded Arch Linux ISO image.

  1. Download the Arch Linux ISO: Verify the integrity of the downloaded ISO using the provided checksums on the Arch Linux website.
  2. Create a Bootable USB Drive: Use a tool like Rufus (Windows), Etcher (cross-platform), or the `dd` command (Linux) to create the bootable USB drive.
    • Using Rufus (Windows):
      • Open Rufus.
      • Select your USB drive in the “Device” dropdown.
      • Click “SELECT” and choose the downloaded Arch Linux ISO image.
      • Ensure the “Boot selection” is set to “Disk or ISO image”.
      • Leave other settings at their defaults and click “START”.
      • A warning message will appear; click “OK” to proceed.
      • Wait for the process to complete.
    • Using Etcher (Cross-Platform):
      • Open Etcher.
      • Click “Flash from file” and choose the downloaded Arch Linux ISO image.
      • Click “Select target” and choose your USB drive.
      • Click “Flash!” and wait for the process to complete.
    • Using `dd` command (Linux):
      • Identify your USB drive using `lsblk`. Be absolutely certain you select the correct drive. It will be something like `/dev/sdb` but make sure you are not selecting your hard drive!
      • Run the following command, replacing `/dev/sdX` with the correct USB drive identifier:

        bash
        sudo dd bs=4M if=path/to/archlinux.iso of=/dev/sdX status=progress oflag=sync

        Warning: This command will erase all data on the USB drive. Double-check the drive identifier before running it. Using the wrong drive here can destroy your existing OS.

      • Wait for the process to complete.

Step 2: Booting from the USB Drive

  1. Restart your computer.
  2. Enter BIOS/UEFI settings: During startup, press the key indicated by your computer manufacturer (usually Delete, F2, F12, Esc, or another key). This key is often shown on the initial boot screen.
  3. Change the boot order: In the BIOS/UEFI settings, find the boot order options and set the USB drive as the primary boot device.
  4. Save the changes and exit: Save the changes you made to the boot order and exit the BIOS/UEFI settings. Your computer should now boot from the USB drive.
  5. Select “Arch Linux archiso x86_64 UEFI” (or similar) from the boot menu.
  6. Wait for the Arch Linux live environment to load. You should be presented with a command prompt.

Step 3: Connecting to the Internet

A working internet connection is required to download packages during the installation. Archiso attempts to automatically connect to a network using DHCP. If you are using a wired connection, it should connect automatically. For Wi-Fi, follow these steps:

  1. List available wireless interfaces:
    bash
    iwctl device list

    Identify the name of your wireless interface (e.g., `wlan0`).

  2. Scan for available networks:
    bash
    iwctl station wlan0 scan

    Replace `wlan0` with the actual name of your wireless interface.

  3. List available networks:
    bash
    iwctl station wlan0 get-networks

  4. Connect to your Wi-Fi network:
    bash
    iwctl station wlan0 connect SSID

    Replace `wlan0` with your wireless interface and `SSID` with the name of your Wi-Fi network. You will be prompted for the Wi-Fi password.

  5. Verify the internet connection:
    bash
    ping archlinux.org

    If you receive replies, your internet connection is working.

Step 4: Partitioning the Hard Drive

This is a crucial step. Incorrect partitioning can lead to data loss on your existing operating system. Make absolutely sure you are selecting the correct partitions and drives.

You need to create partitions for Arch Linux. At a minimum, you’ll need a root partition (`/`) and a swap partition. If you are using UEFI, you will also need an EFI system partition. It’s generally recommended to create a separate `/home` partition for user data.

  1. Identify your hard drives:
    bash
    lsblk

    Identify the disk where you want to install Arch Linux (e.g., `/dev/sda`, `/dev/nvme0n1`). Be absolutely certain you select the correct drive.

  2. Launch `cfdisk` or `fdisk`: (I strongly suggest using `cfdisk` for beginners.)
    bash
    cfdisk /dev/sda

    Replace `/dev/sda` with the correct disk identifier.

  3. Create the partitions:
    • EFI System Partition (ESP) (Required for UEFI systems):
      • Create a partition with a size of at least 512MB. 1GB is a safe choice.
      • Set the partition type to “EFI System”. In `cfdisk` you do this by selecting the partition, choosing “Type”, then selecting “EFI (FAT-12/16/32)”.
      • Format the partition to FAT32 (later).
    • Swap Partition:
      • Create a partition for swap space. The size should generally be equal to the amount of RAM you have, but this is just a rule of thumb. If you have a lot of RAM (e.g., 32GB+) you might not need a swap partition or you can make it smaller. You can also use a swap file instead of a dedicated partition (see later).
      • Set the partition type to “Linux swap”. In `cfdisk` you do this by selecting the partition, choosing “Type”, then selecting “Linux swap”.
    • Root Partition (`/`):
      • Create a partition for the root file system. Allocate at least 20GB, but a larger size is recommended depending on your planned usage.
      • Set the partition type to “Linux Filesystem”. In `cfdisk` this will be the default if no other type is selected.
    • Home Partition (`/home`) (Optional but recommended):
      • Create a partition for the `/home` directory. Allocate the remaining space on the disk.
      • Set the partition type to “Linux Filesystem”. In `cfdisk` this will be the default if no other type is selected.
  4. Write the changes to disk: In `cfdisk`, select “Write” and confirm by typing “yes”.
  5. Quit `cfdisk`: Select “Quit”.

Step 5: Formatting the Partitions

Now you need to format the partitions you created.

  1. Format the EFI System Partition:
    bash
    mkfs.fat -F32 /dev/sda1

    Replace `/dev/sda1` with the actual device identifier of your EFI System Partition.

  2. Format the Swap Partition:
    bash
    mkswap /dev/sda2
    swapon /dev/sda2

    Replace `/dev/sda2` with the actual device identifier of your Swap Partition.

  3. Format the Root Partition:
    bash
    mkfs.ext4 /dev/sda3

    Replace `/dev/sda3` with the actual device identifier of your Root Partition. `ext4` is the recommended filesystem.

  4. Format the Home Partition (if created):
    bash
    mkfs.ext4 /dev/sda4

    Replace `/dev/sda4` with the actual device identifier of your Home Partition.

Step 6: Mounting the Partitions

Mount the partitions to the `/mnt` directory, which will serve as the mount point for the new Arch Linux system.

  1. Mount the Root Partition:
    bash
    mount /dev/sda3 /mnt

    Replace `/dev/sda3` with the actual device identifier of your Root Partition.

  2. Create the `/mnt/boot` directory:
    bash
    mkdir /mnt/boot

  3. Mount the EFI System Partition to `/mnt/boot`:
    bash
    mount /dev/sda1 /mnt/boot

    Replace `/dev/sda1` with the actual device identifier of your EFI System Partition.

  4. Create the `/mnt/home` directory (if you have a separate home partition):
    bash
    mkdir /mnt/home

  5. Mount the Home Partition:
    bash
    mount /dev/sda4 /mnt/home

    Replace `/dev/sda4` with the actual device identifier of your Home Partition.

Step 7: Installing the Base System

Use the `pacstrap` script to install the base Arch Linux packages.

  1. Run `pacstrap`:
    bash
    pacstrap /mnt base linux linux-firmware nano vim dhcpcd networkmanager intel-ucode amd-ucode

    • `/mnt` is the mount point.
    • `base` is a package group containing essential packages.
    • `linux` is the Linux kernel.
    • `linux-firmware` is the firmware for the kernel.
    • `nano` and `vim` are text editors (choose at least one).
    • `dhcpcd` is a DHCP client for automatic network configuration.
    • `networkmanager` and `dialog` are useful for managing network connections after installation.
    • `intel-ucode` and `amd-ucode` are microcode updates for Intel and AMD processors, respectively. Include the appropriate one for your CPU.

    You can add more packages if you want. Common additions include `base-devel` (for building software from source), `git`, and `wget`.

  2. Wait for the installation to complete. This may take some time depending on your internet connection.

Step 8: Configuring the System

Generate the `fstab` file, configure the system locale, set the hostname, and configure the root password.

  1. Generate `fstab`:
    bash
    genfstab -U /mnt >> /mnt/etc/fstab

    This command generates the `/etc/fstab` file, which contains information about the partitions that should be mounted at boot time.

  2. Verify `fstab`:
    bash
    cat /mnt/etc/fstab

    Check the contents of `/mnt/etc/fstab` to ensure that the partitions are listed correctly.

  3. Chroot into the new system:
    bash
    arch-chroot /mnt

    This command changes the root directory to `/mnt`, allowing you to configure the new Arch Linux system.

  4. Set the timezone:
    bash
    ln -sf /usr/share/zoneinfo/Region/City /etc/localtime
    hwclock –systohc

    Replace `Region/City` with your appropriate timezone (e.g., `America/Los_Angeles`).

  5. Configure the locale:
    • Uncomment your desired locale in `/etc/locale.gen`. For example, to enable US English with UTF-8 encoding, uncomment `en_US.UTF-8 UTF-8`. Use `nano /etc/locale.gen` or `vim /etc/locale.gen` to edit the file.
    • Generate the locale:

      • bash
      locale-gen

    • Set the `LANG` environment variable in `/etc/locale.conf`:

      • bash
      echo ‘LANG=en_US.UTF-8’ > /etc/locale.conf

      Replace `en_US.UTF-8` with your chosen locale.

  6. Set the hostname:
    bash
    echo ‘myarchlinux’ > /etc/hostname

    Replace `myarchlinux` with your desired hostname.

  7. Configure the network:
    • Enable NetworkManager:

      • bash
      systemctl enable NetworkManager

  8. Set the root password:
    bash
    passwd

    Enter and confirm the new root password.

  9. Install a boot loader (GRUB):

    A boot loader is necessary to boot Arch Linux. GRUB is the most common choice.

    • Install GRUB:
      bash
      pacman -S grub efibootmgr

      `efibootmgr` is required for UEFI systems.

    • Configure GRUB:
      • For UEFI systems:
        bash
        grub-install –target=x86_64-efi –efi-directory=/boot –bootloader-id=ArchLinux

      • For BIOS systems:
        bash
        grub-install –target=i386-pc /dev/sda

        Replace `/dev/sda` with the disk where you installed Arch Linux.

    • Generate the GRUB configuration file:
      bash
      grub-mkconfig -o /boot/grub/grub.cfg

  10. (Optional) Install microcode updates:
    • If you included `intel-ucode` or `amd-ucode` when installing the base system, you need to update the boot loader to include the microcode. Edit `/etc/default/grub` with `nano` or `vim` and add the following line:

      • GRUB_EARLY_INITRD_LINUX_DEFAULT=”/boot/intel-ucode.img” # For Intel
      GRUB_EARLY_INITRD_LINUX_DEFAULT=”/boot/amd-ucode.img” # For AMD

    • Then, regenerate the GRUB configuration file:

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

  11. Exit the chroot environment:
    bash
    exit

Step 9: Unmounting Partitions and Rebooting

  1. Unmount the partitions:
    bash
    umount -R /mnt

  2. Reboot the system:
    bash
    reboot

  3. Remove the USB drive: After running `reboot` immediately remove the USB installation media.

Step 10: Booting into Arch Linux and Configuring the Desktop Environment

  1. Select Arch Linux from the GRUB menu.
  2. Log in as root using the password you set earlier.
  3. Install a desktop environment and display manager (optional but highly recommended):

    Choose a desktop environment such as XFCE, GNOME, KDE Plasma, or others. A display manager (like LightDM, SDDM, or GDM) provides a graphical login screen.

    Example using XFCE and LightDM:

    • Install XFCE and LightDM:

      • bash
      pacman -S xfce4 xfce4-goodies lightdm lightdm-gtk-greeter

    • Enable LightDM:

      • bash
      systemctl enable lightdm

    Example using GNOME and GDM:

    • Install GNOME and GDM:

      • bash
      pacman -S gnome gnome-extra gdm

    • Enable GDM:

      • bash
      systemctl enable gdm

    Example using KDE Plasma and SDDM:

    • Install KDE Plasma and SDDM:

      • bash
      pacman -S plasma-meta sddm

    • Enable SDDM:

      • bash
      systemctl enable sddm

  4. Create a user account:
    bash
    useradd -m -g users -G wheel username
    passwd username

    Replace `username` with your desired username. Set a password for the new user. The `-m` flag creates a home directory. The `-g users` adds the user to the `users` group. The `-G wheel` adds the user to the `wheel` group which will allow them to use `sudo`.

  5. Enable `sudo` for the user (optional but recommended):
    • Install `sudo`:

      • bash
      pacman -S sudo

    • Edit the `/etc/sudoers` file using `visudo`:

      • bash
      visudo

    • Uncomment the line `%wheel ALL=(ALL) ALL` to allow users in the `wheel` group to use `sudo`. (Remove the `#` character at the beginning of the line.)
  6. Reboot the system:
    bash
    reboot

  7. Log in to the desktop environment using the user account you created.

Step 11: Configuring Dual Boot with Existing OS

After installing Arch Linux, you may need to configure GRUB to detect your existing operating system (e.g., Windows). Often this is automatically configured during the grub installation, but sometimes you must do it manually.

  1. Boot into Arch Linux.
  2. Install `os-prober`:
    bash
    pacman -S os-prober

  3. Run `os-prober`:
    bash
    os-prober

    This command will scan your system for other operating systems.

  4. Generate the GRUB configuration file:
    bash
    grub-mkconfig -o /boot/grub/grub.cfg

    This will update the GRUB menu with the detected operating systems.

  5. Reboot the system:
    bash
    reboot

  6. Select your existing operating system from the GRUB menu.

Troubleshooting

  • No internet connection: Double-check your Wi-Fi credentials or wired connection. Verify that the network interfaces are properly configured.
  • Boot problems: Ensure that GRUB is installed correctly and that the EFI System Partition is mounted correctly (for UEFI systems).
  • Partitioning errors: Review the partitioning scheme and ensure that the partitions are created and formatted correctly.
  • Package installation errors: Verify the internet connection and check for any errors during the `pacstrap` process.
  • Graphical environment issues: Make sure the display manager and desktop environment are installed and enabled correctly. Check the logs for error messages.

Conclusion

Installing Arch Linux can be challenging, but this guide provides a comprehensive walkthrough for dual-booting it alongside an existing operating system. By following these steps carefully, you can successfully install Arch Linux and enjoy its flexibility and customization options. Remember to be patient and consult the Arch Linux Wiki (https://wiki.archlinux.org/) for more detailed information and troubleshooting tips.

0 0 votes
Article Rating
Subscribe
Notify of
0 Comments
Oldest
Newest Most Voted
Inline Feedbacks
View all comments