everest-logo Home About Install Packages Downloads Docs Errata Git ↗

Install

Installation Handbook

This guide is the official installation handbook for Everest Linux.

PRELIMINARY WARNINGS:

WARNING 1: Using unofficial guides is not recommended, as they may be outdated, or unreliable. The official guide is located at https://www.everestlinux.org/install.

WARNING 2: Simply copy and pasting commands from this guide won't cut it, and you'll likely end up with a broken installation. Ensure you know what each command does, and how to tailor it to your system, if necessary.

WARNING 3: Everest is not for the faint of heart. There is absolutely no hand holding provided, you are on your own. If you have never touched Linux in your life, Everest is most certainly not for you. There are many distributions which provide a much better user experience for those new to Linux, we personally recommend Linux Mint.

WARNING 4: Everest in its current state is highly experimental. Install at your own risk.

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

Prerequisites

The following steps are required to complete an installation:

  1. Set up the build environment
  2. Download a system image
  3. Unpack the system image
  4. Change root into the new system
  5. Set up the Glacier system profile and package index
  6. Install programs
  7. Install the Linux kernel
  8. Set up init scripts and services
  9. Install the bootloader
  10. Reboot the system
Note that Everest is highly flexible. That being said, it is up to you to make modifications yourself.

Run commands prefixed with (user)$ as an unprivileged user.

Run commands prefixed with (root)# as the root user.

Run commands prefixed with (chroot)# inside the chroot environment.

Set up the environment

On the host system being used to install Everest, a properly set up environment containing certain programs and directories must be set up to ensure the installation can take place. This section will go into detail on how to set up this environment.

A system mountpoint is where the new system's root (/) will be. Where you put this doesn't matter, as the host system used to build the system won't be included in the final installation. In this example, we will use /mnt/everest.

Create a system mountpoint:

(root)# mkdir -pv /mnt/everest

A variable pointing to the system mountpoint may be useful in the future, as it will save you a bit of typing.

Create a variable for the system mountpoint:

(root)# SYS_MNT=/mnt/everest

Partitions must be created on the drive you wish to install Everest to. The typical partition layout on an Everest system may differ from other distributions.

The typical layout is:

Mount point Type Suggested size
/mnt/everest/boot EFI system partition (esp) No smaller than 256 MB, no larger than 1 GB (minimum 1 GB if installing multiple kernels)
/mnt/everest/usr User partition No smaller than 25 GB, recommended size varies.
/mnt/everest/home Home partition It depends
/mnt/everest Root filesystem Remainder of the drive

Partition the target drive:

(root)# cfdisk /dev/sdX

A valid filesystem is required on the drive.

Most filesystems should work, however ensure the system has the corresponding package for whatever filesystem you choose.

For example, if XFS is used, when installing the system:

(chroot)# gpkg -f xfsprogs

CAUTION:

Zfs is not officially supported by Everest, and requires a lot of configuration to work properly. Use Zfs at your own risk.

This stance may change at a later date, however currently there is no official Everest documentation for setting up Zfs.

In this example, Ext4 will be used.

Create a filesystem:

(root)# mkfs.ext4 /dev/root

(root)# mkfs.ext4 /dev/usr

The EFI system partition (esp) must be formatted as FAT32.

(root)# mkfs.vfat -F32 /dev/boot

Mount the root partition to the system mountpoint:

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

Some additional directories may need to be created.

Create extra needed directories:

(root)# mkdir /mnt/everest/boot

(root)# mkdir /mnt/everest/usr

Mount the remaining partitions:

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

(root)# mount /dev/usr /mnt/everest/usr

Create remaining directories on /usr with mkusrskel:

(root)# mkusrskel -d /mnt/everest/usr

Downloading a system image

An Everest system image provides an incomplete root filesystem which users can build a system off of. This includes system programs, libraries, Glacier, among others. Users should be careful of which image they choose, as switching in the future is arduous, time consuming, and requires rebuilding a lot of packages.

It's a lot better to get it right the first time, rather than trying to get it right later.

Do some thorough planning to ensure you get the right system image. For instance, ask yourself a few questions, such as:

  1. Do I need 32 bit libraries?
  2. Will I be using proprietary software that cannot be recompiled?
  3. Do I require a specific C library for my hardware setup?
  4. Do I want to set up NSA Security Enhanced Linux (SELinux)
  5. Do I want an init system other than Busybox's built in init configured out of the box?
NOTE:

Make sure you're happy with the system image you choose. While migrating in the future is possible, it requires rebuilding the majority of the system, takes a substantial amount of time, and may present other issues.

WARNING:

As a beginner, under NO CIRCUMSTANCES should you use a system image omitting 32 bit libraries unless it is ABSOLUTELY NECESSARY.

Downloading a system image that is severely out of date is not recommended. Many programs, such as the kernel or SSL library will be vulnerable to attacks.

Download a system image with wget:

(user)$ wget https://git.everestlinux.org/EverestLinux/everest/raw/branch/main/releases/SYSTEM_IMAGE.tar.xz

Unpacking the system image

Now that a system image has been downloaded, we can unpack it.

Ensure the system image is inside the system mountpoint, otherwise you may run into trouble.

Since a Linux root filesystem is complex, and many different files need to be owned by certain users, or have certain permissions, simply running tar xf will result in a broken image, as the proper permissions are not carried over. A couple extra flags are needed to preserve these permissions in the unpacked image.

Unpack the system image:

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

If this command was run correctly, you shouldn't need to edit any permissions manually.

In case permissions were changed, you can use the prep command from everest-build-tools.

CAUTION:

Caution should be exercised when running prep as it can mess with permissions already existing on the system.

Chrooting into the system mountpoint

Although we have a relatively complete root filesystem at this point, many essential programs are still missing. These include the kernel and bootloader. Without these, the system is unable to boot. At this point, we must chroot into the new system. This will allow us to complete the system's build process without booting into it.

Chroot into the new system:

(root)# everest-chroot /mnt/everest

Change the shell prompt to differentiate the two environments:

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

Install packages

Any programs you wish to install, such as display servers, login managers, and desktop environments, should be installed now. The kernel can take multiple hours to compile on some hardware.

Glacier manages packages on the system, and it allows users to install, or 'merge' their own. It is recommended to get familiar with this system.

WIKI: Introduction to Glacier

Glacier may not function correctly if the package database has not been downloaded. If gpkg outputs the following error: [x] Local package database does not exist., run:

(chroot)# glacier-update-pkgdb

Install the Linux kernel

The most important part of the system, the kernel, which allows hardware to communicate with software, is ready to be installed.

If needed, merge the linux-firmware package, which provides device firmware:

(chroot)# gpkg -f linux-firmware

At this stage, you can decide which kernel you want to install. In Everest's package repository, many prebuilt kernels are available, as well as the source code, should you wish to compile your own.

Option 1: Custom kernel

Compiling a custom kernel is the recommended option for most users, as it allows the most control over what exactly is installed on your system.

Download the kernel's source tree:

(chroot)# gpkg -f linux

The source tree will be located under /usr/src/linux.

Inside /usr/src/linux, ensure the source tree is completely clean by running the following:

(chroot)# make mrproper

The kernel must be configured before it is compiled.

Users installing systemd should enable IPv6 in the kernel configuration:

KERNEL: Enbable support for IPv6

Networking support --->

      Networking options --->

            <*> The IPv6 protocol [CONFIG_IPV6]

Recommended options are not provided - it is up to you to configure the kernel for your setup.

Configure the kernel:

(chroot)# export EVEREST_ARCH="$(echo $MACHTYPE)"

(chroot)# ARCH=$EVEREST_ARCH make defconfig

(chroot)# ARCH=$EVEREST_ARCH make menuconfig

Once the kernel is configured, compile it:

(chroot)# make && make modules install

Option 2: Distribution kernel

For those who do not wish to configure a custom kernel, or likewise do not have the time or system resources to do so, a distribution kernel provides a binary kernel. However, there are a couple of pitfalls to this option:

  1. Distribution kernels are not fine tuned to your system, they are generic and bloated
  2. Distribution kernels are managed by their respective development teams, who must be relied upon for fixes
  3. Distribution kernels deprive the user of the experience gained by configuring and compiling a custom kernel

Everest offers many distribution kernels, some notable ones include:

  1. linux-everest
  2. linux-zen
  3. linux-hardened

Install a distribution kernel:

(chroot)# gpkg -f world/linux-{everest,zen,hardened}

Build an initramfs

Depending on your system, an initramfs may be required. For example, users of distribution kernels will ALWAYS need to build an initramfs, while those who configured and compiled their own will usually not need one.

To build an initramfs, you will need dracut. Install dracut:

(chroot)# gpkg -f world/dracut

Build an initramfs:

(chroot)# dracut

Configure the system

Now that the kernel is installed, various other parts of the system should be configured.

Create /etc/fstab, which provides the system with information about mounted filesystems.

For example, on a system with a root, /usr, and boot partition, /etc/fstab will look like this:

FILE: /etc/fstab

/dev/sda1      /      ext4      noatime      0 1

/dev/sda2      /usr      ext4      noatime      0 1

/dev/sda3      /boot      vfat      defaults,noatime      0 2

System services that some may find helpful, such as a cron daemon or logging daemon, should be set up now.

On systems using systemd:

(chroot)# systemctl enable cronie chronyd sysklogd

On systems without a service manager, all services under /etc/init.d will be initialied by rcS.

The system's timezone is read from /etc/localtime, which is a symlink.

In case timezone information is missing from /usr/share/zoneinfo, install it:

(chroot)# gpkg -f world/tzdata

Create /etc/localtime:

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

The hostname assigns a name to the system. This can be changed at any time.

Set the hostname:

(chroot)# echo hostname > /etc/hostname

Or, on systemd:

(chroot)# hostnamectl hostname hostname

A network connection is very important, and there are multiple ways to set one up.

CAUTION:

Ensure your network is fully set up before proceeding with any other steps. It's better to get it right the first time, rather than trying to fix it later.

First, ensure the desired network interface is not blocked by rfkill:

(chroot)# rfkill

If the network interface is blocked:

(chroot)# rfkill unblock interface

The network can now be configured.

Option 1: Busybox networking

Busybox includes networking tools that can quickly configure the network.

On a busybox system, the network can be set up with one simple command:

(chroot)# ifup

rcS will also run this command at boot time.

Option 2: dhcpcd and wpa_supplicant

On systems without Busybox, dhcpcd can be used. This is another very simple solution.

Install dhcpcd:

(chroot)# gpkg -f world/dhcpcd

Install wpa_supplicant:

(chroot)# gpkg -f world/wpa_supplicant

rcS will start dhcpcd at boot time.

Option 3: NetworkManager

NetworkManager is recommended on systems using systemd as the init system.

NetworkManager should be fairly easy and straightforward to set up for most.

Install NetworkManager:

(chroot)# gpkg -f world/networkmanager

Enable and start NetworkManager:

(chroot)# systemctl enable --now NetworkManager

The /etc/hosts file is used to resolve IP addresses not resolved by the DHCP server.

FILE: /etc/hosts

127.0.0.1      localhost

::1            localhost

127.0.1.1      localdomain hostname

The root password is extremely important, as it controls access to the root user, the most powerful user on the system.

Ensure your chosen root password is strong enough where it cannot be guessed easily.

Set the root password:

(chroot)# passwd

If remote access is desired on the system, install sshd:

(chroot)# gpkg -f world/sshd

Using the root account for daily use is not recommended. Create an unprivileged user:

(chroot)# adduser USERNAME

A privilege elevation program is recommended for most users. The most popular choices are sudo and doas, with doas being recommended for most users.

Install doas:

(chroot)# gpkg -f world/doas

Create /etc/doas.conf:

FILE: /etc/doas.conf

permit USER as root

Configure the bootloader

Now that the system is correctly configured and the kernel is installed, the final step can proceed - installing the bootloader. Without a bootloader, the system will be unable to load the Linux kernel upon boot.

This guide only mentions GRUB, however note that other bootloaders are supported.

The GRUB package for certain system profiles compiles BIOS AND UEFI support. If you wish to remove UEFI support, you will have to manually patch the package file.

Unless you are using some obscure system profile, or simply want to make your system as small as possible, you definitely will not have to worry about this.

WIKI: Introduction to Glacier

Merge grub:

(chroot)# gpkg -f grub

Install GRUB for BIOS:

(chroot)# grub-install /dev/sda

If configuring GRUB to boot with UEFI, a few extra things need to be configured.

The following kernel options need to be configured in order to support UEFI:

KERNEL: Enable UEFI support

Processor type and features --->

      [*] EFI runtime service support

-*- Enable the block layer --->

      Partition Types --->

            [ /*] Advanced partition selection

            [*] EFI GUID Partition support

Device Drivers --->

      Firmware Drivers --->

            [*] Mark VGA/VBE/EFI FB as generic system framebuffer

      Graphics Support --->

            <*> Direct Rendering Manager (Xfree86 4.1.0 and higher DRI support) --->

            [*] Enable legacy fbdev support for your modsetting driver

            <*> Simple framebuffer driver

            Frame buffer Devices --->

                  <*> Support for frame buffer devices --->

            Console display driver support --->

                  -*- Framebuffer Console support

File systems --->

      DOS/FAT/EXFAT/NT Filesystems --->

            <*/M> VFAT (Windows-95) fs support

      Psuedo filesystems --->

            <*/M> EFI Variable filesystem

      -*- Native language support --->

            <*/M> Codepage 437 (United States, Canada)

            <*/M> NLS ISO 8859-1 (Latin 1; Western European Languages)

Install GRUB for UEFI:

(chroot)# grub-install --target=x86_64-efi --efi-directory=/boot

For GRUB to work correctly, a configuration file must be created. Create one now:

(chroot# grub-mkconfig -o /boot/grub/grub.cfg

Exit chroot

The system has been finished. If everything is done to your liking, you can now exit the chroot environment.

(chroot)# exit

Unmount all mounted partitions:

(root)# umount -l /mnt/everest/dev/{shm,pts}

(root)# umount -R /mnt/everest

Reboot the system:

(root)# reboot

Ensure the newly installed bootloader is first to boot, otherwise you will end up in your old system again. If you used a live USB to install Everest, make sure you remove it before rebooting.

Conclusion

If all went well, Everest should boot up with no problems.

Remove the system image from /:

(root)# rm /everestlinux-*.tar.*

With the installation out of the way, you now have a minimal Linux environment to play around in, and to build around.

Many things still need to be set up and configured.

See: General Recommendations

If you require assistance, reach out to the community on Discord (HJzJUwSmDf) or IRC (#everestlinux on libera.chat)