# Everest Linux - Install

Home About Install Packages Downloads Wiki Git

## Installation Handbook

This is the official installation guide for Everest Linux.

Using unofficial guides is not recommended as they may be

out of date.

Simply following this guide blindly is a great way to end up

with a broken installation. Ensure you have a rough idea of

what each command does.

If you need assistance, reach out on IRC (#everestlinux) or Discord.

## Prerequisites

The following steps will be used to complete the installation:

- Set up the environment

- Download the Everest Linux system image

- Unpack the system image

- Chroot into the new system

- Install desired programs

- Install the Linux kernel

- Set up init scripts/services

- Reboot the system

Note: Everest is highly flexible. If you are changing anything in this guide, it is assumed you know exactly what to do.

Run `(user)$` commands as an unprivileged user.

Run `(root)#` commands as the root user.

Run `(chroot)#` commands inside the chroot environment.

## Set up the environment

Our environment needs to be set up correctly for the installation.

Create the system mountpoint:

`(root)# mkdir -pv /mnt/everest`

Although it may not be used, assign the system mountpoint a variable:

`(root)# export SYS_MNT=/mnt/everest`

Partition your drive:

`(root)# cfdisk /dev/sdX`

Mount the root partition to the system mountpoint:

`(root)# mount /dev/sdX /mnt/everest`

If needed, create the boot directory:

`(root)# mkdir -pv /mnt/everest/boot`

Mount the boot partition:

`(root)# mount /dev/sdX /mnt/everest/boot`

## Downloading the Everest system image

An Everest system image is an incomplete root filesystem, which

provides a strong base to build off of

Not all system images are the same. Some differences are:

- The init system

- The standard C library

- The architecture

- SELinux support

- Multilib support

Ensure you download the image you want. Migrating in the future

is not officially supported or even recommended.

Download an image with `wget`:

`(user)$ wget SYSTEM_IMAGE_LINK`

## Unpacking the system image

The system image can now be unpacked.

Ensure the system image is located under the system mountpoint.

Note that a simple `tar -xvf` will cause errors with

permissions. Therefore, a few extra flags are needed.

Unpack the system image:

`(root)# tar -xpvf SYSTEM_IMAGE --xattrs-include='*.*' --numeric-owner`

This will ensure all file ownership is compliant.

## Chrooting into the new installation

The system is in a partially working state.

If we were to call it a day and reboot now, it wouldn't be possible.

Many critical parts of the system are missing, including the

bootloader and kernel. Chrooting allows us to make modifications

to the target system, without actually booting into it.

Before chrooting, additional filesystems must be mounted.

Mount these filesystems:

`(root)# mount --types proc /proc /mnt/everest/proc`

`(root)# mount --rbind /sys /mnt/everest/sys`

`(root)# mount --make-rslave /mnt/everest/sys`

`(root)# mount --rbind /dev/ /mnt/everest/dev`

`(root)# mount --make-rslave /mnt/everest/dev`

`(root)# mount --bind /run /mnt/everest/run`

`(root)# mount --make-slave /mnt/everest/run`

Chroot into the system:

`(root)# chroot --userspec=0:0 /mnt/everest /bin/sh`

Change the shell prompt to avoid confusion:

`(chroot)# export PS1="(chroot) ${PS1}" && source /etc/profile`

## Install programs

Any programs you wish to install should be installed now.

This is because the Linux kernel takes multiple hours to compile.

See General Recommendations for ideas. Note that some

programs assume the system is installed, so use caution.

## Install the Linux kernel

The most important part of the system, the kernel, is ready to be installed.

Install the linux-firmware package, which provides device firmware:

`(chroot)# glacier -f linux-firmware`

Download the kernel's source tree:

`(chroot)# glacier -f linux`

Change directory to the kernel's source tree:

`(chroot)# cd /usr/src/linux`

Ensure the kernel source tree is clean:

`(chroot)# make mrproper`

Configure the kernel:

`(chroot)# ARCH="your-arch-here" make defconfig && make menuconfig`

Compile the kernel:

`(chroot)# make && make modules_install`

Install the kernel:

`(chroot)# make install`

On some systems, an initial RAM filesystem (initramfs)

may be needed to ensure proper booting.

If you want an initramfs, install dracut:

`(chroot)# glacier -f dracut`

Build an initramfs:

`(chroot)# dracut`

## Configure the system

Some components of the system mus be configured.

Create `/etc/fstab`.

Enable system services, such as a cron daemon, logger, etc:

`(chroot)# /etc/init.d/{cronie,chronyd,sysklogd} start`

`(chroot)# systemctl enable --now cronie chronyd sysklogd`

Set the timezone:

`(chroot)# ln -svf /usr/share/zoneinfo/Region/City /etc/localtime`

Configure the locale:

`(chroot)# echo "LANG=en_US.UTF-8" > /etc/locale.conf`

Set the system hostname:

`(chroot)# echo "my_hostname" > /etc/hostname`

Other things you might want to configure are:

- /etc/doas.conf or /etc/sudoers

- /etc/inittab

## Configure the bootloader

One more critical component is needed: the bootloader

While any bootloader can be installed, this guide recommends

`systemd-boot` and `grub`.

For systemd-boot/gummiboot:

Install the standalone package for systemd-boot if systemd is not installed:

`(chroot)# glacier -f gummiboot`

Install the bootloader:

`(chroot)# bootctl install`

Edit `/boot/loader/loader.conf` to your liking.

Create a boot entry at `/boot/loader/entries/everest.conf`.

For GRUB:

Install the GRUB package that corresponds to your system:

`(chroot)# glacier -f grub-bios`

`(chroot)# glacier -f grub-uefi`

Install GRUB:

`(chroot)# grub-install /dev/sdX # for BIOS`

`(chroot)# grub-install --target=x86_64-efi --efi-directory=/boot --bootloader-id=grub # for UEFI`

Create a GRUB configuration file:

`(chroot)# grub-mkconfibg -o /boot/grub/grub.cfg`

## Finishing the installation

Every component of the system has been configured, and we can now

boot into it.

Exit the chroot environment:

`(chroot)# exit`

Unmount all partitions from the system mountpoint:

`(root)# umount -R /mnt/everest`

Power off the system:

`(root)# poweroff`

Ensure you remove the installation media or you

will not boot into the new system.

## Post installation

A base Everest system is very minimal.

Most users will want to configure extra components, such as a window

manager, or sound. See: General Recommendations for more info.