Before starting we need a very quick setup. You will need to install some software:

If anything is missing or if you have the commands for other distros send me a DM on discord (;

Explained:

sudo ---> This means we are using root (superuser) privilege, always be careful when using a command with sudo!

You need to start the docker service.

Lets download and enter the Docker-LFN

If ever you get locked out of your Docker-LFN.

Lastly, if you need to delete Docker-LFN:

Docker-LFN provides an directory tree and the programs needed for us to create our LFN.

Here is the directory tree that is created:

Docker-LFN

This all happens in Docker-LFN

The GNU C Library - GNU Project - Free Software Foundation

Glibc is the base of all library, it allows us to load dynamic libs through /lib64/ld-linux-x86-64.so.2 and gives us an implementation of the standard C lib (libc.so.6)

Explained:

cd LFN ---> Change Directory.

wget https://ftp.gnu.org/gnu/glibc/glibc-2.41.tar.gz ---> Download the archive for Glibc

tar -xf glibc-2.41.tar.gz ---> Uncompress the archive.

mkdir build-glibc ---> Create directory: build-glibc

../glibc-2.41/configure ---> Configure script is a standard across GNU software, it allows to configure the software before compiling.

--without-selinux ---> Removes selinux support. Not in LFN.

--libdir=/usr/lib ---> Set where ld-linux will search for dir, by default we have /usr/lib64 but we also want /usr/lib.

--prefix=/usr ---> By default, most software is installed in /usr/local/... we want to install it in the right place for us to use it, which is /usr. KEEP IN MIND a lot of software will have hard-coded paths, we cannot directly put /LFN/root/usr here.

make -j8 ---> Compile the software that we just configured.

make install ---> Make install makes the software deploys itself on the system.

DESTDIR=/LFN/root ---> Set the new / of the make install. Instead of putting things in /usr it will put things in /LFN/root/usr

NCURSES – New Curses

Ncurses is a library that allows program to make TUIs(Terminal User interfaces). Ncurses' libs allows bash (and more) to work, we also need to compile the wide character version which has its libs end in 'w'. (get the latest here: https://ftp.gnu.org/gnu/ncurses/ )

Explained:

CFLAGS='-std=gnu17' ---> Ncurse is kinda broken and needs us to compile using the gnu17 standard of C.

--with-shared ---> Creates libs(.so files)

--with-termlib ---> Creates libtinfow.so.6 (used by bash)

--enable-widec ---> Makes sure that ncurses is compatible with wide characters. This will also make all the libs end in w (libncurses.so.6 => libncursesw.so.6)

--with-versioned-syms ---> By default ncurses omits putting a version on the libs. This will make some software unable to use them.

ln -s libncursesw.so.6 /LFN/root/usr/lib/libncurses.so.6 ---> Some software will still search for the non w libs. We can fix this with a symlink to the w lib from the non w lib.

Bash - GNU Project - Free Software Foundation

We need a shell in order to interact with our kernel.

Explained:

ln -s bash /LFN/root/bin/sh ---> Most software won't assume bash but will assume sh for the shell, making a symlink is a standard.

Coreutils - GNU core utilities

We need core utilities like cat ,cp, rm...

Explained:

FORCE_UNSAFE_CONFIGURE=1 ---> Our docker is running as root an coreutils has a protection against it, this is a bypass.

--without-included-regex ---> Removes regex support. PCRE2 (which is needed for this feature) is not yet in LFN (but will be).

util-linux/util-linux

Gives us a bunch of Linux tools like mount.

nano – Text editor

Nano a very simple text editor.

Explained:

--enable-tiny ---> Disables all extra features. Ensure compatibility.

The Linux Kernel Archives

Lets download and config the kernel.

Explained:

git clone https://github.com/torvalds/linux ---> Clone the latest kernel.

--depth 1 ---> Doesn't clone the whole git history. We don't plan to go into any other version so it isn't needed.

make tinyconfig ---> Makes the smallest possible kernel that can be compiled.

make menuconfig ---> Opens the menu for us to config the kernel.

There is a few thing that we want to achieve with the kernel.

/ Here is how you should set the kernel /

General setup --->

----[ ] Configure standard kernel features (expert users)

[*] 64-bit kernel

Processor type and features  --->

----[*] Symmetric multi-processing support

----[*] Linux guest support  --->

--------[*]   Enable paravirtualization code

----(8) Maximum number of CPUs

Power management and ACPI options  --->

----[*] ACPI (Advanced Configuration and Power Interface) Support

General architecture-dependent options --->

----[*] Provide system calls for 32-bit time_t

Executable file formats --->

----[*] Kernel support for ELF binaries

----[*] Kernel support for scripts starting with #!

[*] Networking support --->

----Networking options --->

--------[*] Packet socket

--------[*] Unix domain sockets

--------[*] TCP/IP networking

--------[*] DNS Resolver support (needs the other option ↓ to be shown)

Security options --->

----[*] Enable access key retention support

Device Drivers --->

----[*] PCI support

----Generic Driver Options --->

--------[*] Maintain a devtmpfs filesystem to mount at /dev

--------[*] Automount devtmpfs at /dev, after the kernel mounted the rootfs

----SCSI device support --->

--------[*] SCSI disk support (this will unlock after serial ATA)

----[*] Serial ATA and Parallel ATA drivers (libata) --->

--------[*] Intel ESB, ICH, PIIX3, PIIX4 PATA/SATA support

----[*] Network device support --->

--------[*] Ethernet driver support (NEW) ---> (THIS IS ALREADY MARKED)

------------[*] Intel(R) PRO/1000 Gigabit Ethernet support

----Character devices --->

--------Serial drivers --->

------------[*] 8250/16550 and compatible serial support

------------[*] Console on 8250/16550 and compatible serial port

----Graphics support --->

--------Frame buffer Devices --->

------------[*] Support for frame buffer device drivers --->

---------------[*] VESA VGA graphics support

--------Console display driver support  --->

------------[*] Framebuffer Console support

File systems --->

----[*] The Extended 4 (ext4) filesystem

----[*] Inotify support for userspace

Compile and dump our kernel in the boot dir of LFN, we also take the time to copy the .config we did. We won't have to do it again. (;

Explained:

mv arch/x86/boot/bzImage /LFN/root/boot/ ---> Moves the file bzImage to the boot dir.

ld-linux-x86-64.so.2 can detect libs in 2 ways:

Lets generate that cache!

First time running nano, nano allows to edit and create files.

Content of the file (save and exit using Ctrl-x and than y, than Enter).

Update the ld.so.cache .

Now lets make the init, it can be placed in /, /bin or /sbin, always need to be called "init" and be executable.

The init is the first thing to boot from the userspace by the kernel, it allows us to direct what we want our LFN to do as it boots.

Content of the file (exit using Ctrl-x and than y, than Enter).

Explained:

#!/bin/bash ---> This is called a shebang, it is used to indicate to the kernel that it should open the script using bash.

mount -t proc none /proc ---> Mounts the Proc FS (will be populated by the kernel).

mount -t sysfs none /sys ---> Mounts the Sys FS (will be populated by the kernel).

exec /bin/bash ---> Executes bash for us to use the shell.

Make it executable.

Grub is a bootloader, it is opened by the BIOS to boot the kernel. Grub is a big beast with a lot of feature while being fairly easy to configure.

Now lets create the boot entry.

Content of the file (exit using Ctrl-x and than y, than Enter).

Explained:

menuentry 'LFN' { ---> We have a menuentry called LFN. You could have multiple and the name isn't important.

gfxpayload=1920x1080 ---> Allows us to boot the kernel with a given screen size, you can edit to your preferred size.

set root='(hd0,1)' ---> Sets the disk we are booting from, hd0 means first disk and ,1 means first partition.

linux /boot/bzImage ---> Grub will attempt to boot a linux kernel stored in /boot/bzImage.

root=/dev/sda1 rw ---> Mount /dev/sda1 as Read-Write.

We need to create a disk (in our case 1GB).

Explained:

(CTRL+D) ---> On you keyboard doing CTRL+D quits the session that you are in, this will make you exit docker.

dd if=/dev/zero of=disk.img bs=1M count=1024 ---> Will create an empty 1GB disk.img file.

fdisk disk.img ---> Will format our disk using the msdos standard. Also create a bootable partition.

Mounting our disk using losetup, it will find the next available /dev/loop# and give us access to the partitions at /dev/loop#p#. it will also tell us which loop# it chose.

You can now format the partition to the FS of your choice, given that it was configured into your kernel. if you followed this tutorial without change, you will be using EXT4.

This will be the last thing you have to do to mount an not-new image. don't stop the tutorial if its new (; .

We will find our docker ID and copy the data out of docker into our image (/mnt).

We need a bootloader to tell our system what to do at boot, Grub is a complete, battle-harden bootloader and you will learn to use it. Lets get it onto our drive!

Explained:

--target=i386-pc ---> Grub will set itself to boot from a msdos pc, it is universal and works well with QEMU.

--root-directory=/mnt ---> Grub will install itself in /mnt.

--no-floppy ---> Wont scan for a floppy.

--modules="normal part_msdos ext2 multiboot" ---> Will add modules for ext4 and msdos partitioning.

/dev/loop# ---> Will modify the partition table.

Explained:

sudo umount /mnt ---> Unmount /mnt

sudo losetup -d /dev/loop# ---> Removes our loopback device.

You can now follow #Running LFN to test your creation!

Here is the basic command:

There is some options that you can add to better your experience.

By default, QEMU gives you 128MB, not alot...

You can change 4G for the amount that you want, but at least 4GB.

By default, QEMU gives you 1 core.

Here we have 8 core, you can change it for the needed amount. (and yes cursed amounts like 7 work)

KVM will harness the power of virtualization provided by the hardware and it is wayyyy faster, the host kernel needs to have it enabled and bios too but they are both default now....

The simplest way to get network on QEMU is (but it should be enabled by default):

We are going to install all that is necessary for us to compile from LFN (Without Docker-LFN).

Get back in your Docker-LFN instance:

Explained:

sudo systemctl start docker.service ---> If you have rebooted your machine since last tutorial, docker may not be started.

sudo docker ps -a ---> Prints all docker on the system, allows you to get the ID of your LFN docker.

sudo docker start 4a8954d9ddf1 ---> Start your docker instance. Choose the right id. (;

sudo docker exec -it 4a8954d9ddf1 bash ---> Gets into your docker instance using bash.

https://www.gnu.org/software/binutils/

Contains Assembler and a bunch of tools used by the compiler.

This Linux kernel header file, you can think of them as the connection that any program we compile will use to connect to the kernel.

Explained:

make headers ---> Will generate the Linux Headers.

The basic Gnu C Compiler and its c++ libs. Probably the most technical part of LFN.

https://gcc.gnu.org/

Explained:

./contrib/download_prerequisites ---> Allows to download some of the libs needed to compile GCC. We will also be using some of the libs right after to install on LFN.

--with-build-sysroot=/LFN/root ---> Will build against the headers and libs that we have in our LFN.

--disable-nls ---> Disable Multi-Lingual support.

--disable-multilib ---> 32 bit support, Not needed.

--disable-bootstrap ---> GCC normally compile a compiler and then compile itself with it, skip that step.

--disable-fixincludes ---> GCC normally runs a scripts that scans and modify the headers on the system for better compatibility, this probably won't break anything but it is unnecessary on anything modern.

--enable-languages=c,c++ ---> GCC allows to compile a LOT of languages, only go with C and C++.

https://gmplib.org/

GNU Multiple Precision Arithmetic Library. Used to compile.

Explained:

--host=none-linux-gnu ---> GMP will attempt to scan the host architecture at compile time and 99% fail, this fixes it.

https://www.mpfr.org/

The MPFR library is a C library for multiple-precision floating-point computations with _correct rounding_.

Explained:

make install ---> This is not a mistake, to be able to compile MPC for LFN we will need to install it on docker.

https://www.multiprecision.org/

Multiprecision, is an extention of MPFR.

https://www.gnu.org/software/gettext/

Used to make program multi-lingual.

Make - GNU Project - Free Software Foundation

Make, we all know what it is by now.

GNU M4 - GNU Project - Free Software Foundation

Macros M4 is a macro processor. You can think of it as a powerful and scriptable find and replace. It is used by autoconf (the tool that produce configure).

https://www.gnu.org/software/diffutils/

Provides diff and cmp needed broadly across GNU software.

https://www.gnu.org/software/gawk/

Needed by perl

Explained:

--without-readline ---> We don't have readline yet, we need to disable it.

https://www.gnu.org/software/findutils/

Provides find.

https://www.gnu.org/software/grep/

Grep allows you to search for terms in text or files. Used with Make.

https://github.com/PCRE2Project/pcre2

The PCRE2 lib implements regular expression pattern matching. Integrates with grep and others.

https://www.gnu.org/software/sed/

Very simple find and replace. Used with Make.

https://savannah.gnu.org/projects/patch/

Used to apply patches that were created using diff. Used with Make.

The elfutils project

ElfUtils will provide libelf and simple elf editing tools. Most executable on linux are elf binaries.

westes/flex: The Fast Lexical Analyzer - scanner generator for lexing in C and C++

> [!NOTE] Detailed explanation on what is (F)lex

> Flex allows you to generate lexers. Lexers allow you to do lexing, the act of parsing a stream of text info tokens. follow the link for Examples.

FLEX allows you to generate scanners (Will generate the C code for a scanner to find a specific pattern). Used by the kernel, libcap and others.

https://www.gnu.org/software/tar/

Allows us to unpack and pack archives. We will need alot!

https://www.gnu.org/software/gzip/

GZ compression. We will need with Tar.

https://github.com/tukaani-project/xz

XZ compression. We will need with Tar.

zlib Home Site

Zlib is a compression lib, it provides libz.

https://github.com/facebook/zstd

Zstd is a compression lib/program that can produce and decode .zst .gz .xz .lz4 . Provides libzstd.

Explained:

make DESTDIR=/LFN/root prefix=/usr install ---> Zstd doesn't have a configure so we set the prefix with make install.

https://sourceware.org/bzip2/

Bzip2 is a compression lib, it provides libbz2.

Explained:

make -f Makefile-libbz2_so ---> Bzip2 doesn't generate .so libs by default, lets force it to do so (and copy them).

We will download a few program that we will compile now and in part 3.

Now lets fix the init.

Content of the file (exit using Ctrl-x and than y, than Enter).

Explained:

export ---> Sets a variable.

export CC=/usr/bin/gcc ---> Some programs like there compiler to be defined.

export GCC_EXEC_PREFIX=/usr/libexec/gcc/ ---> Tells GCC where to find internal components (cc1).

export LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.1.0/ ---> ells GCC where to find some internal libs.

If you are watching the vids and you just want to skip to this point, make sure that you start your docker-LFN and run:

It will do all the steps above. You may have to answer some question when it comes to compiling the kernel, just press enter and it will set the default.

DO NOT DO IF YOU ALREADY INSTALLED ANYTHING IT WON'T WORK/BRICK THING UP.

Now out of docker:

We need to create a disk (in our case 1GB).

Explained:

rm disk.img ---> Removes disk.img.

qemu-img create -f qcow2 disk.img 100G ---> Creates a Qcow2 image of size 100G. This image is compressed so it won't take a lot of place and it is optimized for QEMU.

sudo modprobe nbd max_part=8 ---> Enable nbd in the kernel.

sudo qemu-nbd -c /dev/nbd0 disk.img ---> Mount disk.img to /dev/nbd0.

You can now format the partition to the FS of your choice, given that it was configured into your kernel. if you followed this tutorial without change, you will be using EXT4.

This will be the last thing you have to do to mount an not-new image. don't stop the tutorial if its new (; .

We will find our docker ID and copy the data out of docker into our image (/mnt).

We need a bootloader to tell our system what to do at boot, Grub is a complete, battle-harden bootloader and you will learn to use it. Lets get it onto our drive!

Explained:

sudo qemu-nbd -d /dev/nbd0 ---> Removes our NBD device.

You can now follow #Running LFN to test your creation!

File allows us to know what a specific file is.

You can now test (and celebrate) the file command with any file of your choosing!

Keep in mind that our LFN doesn't have any way to shutdown correctly, make sure to do:

before closing QEMU/LFN as to make sure that everything that needs to be written to the disk is.

Lets get LFN on the internet.

http://pkgconf.org/

PKGconf is used by some config script to detect compatible features. PKGconf searches /usr/lib/pkgconfig for .pc files that shows the information about installed programs. It is a replacement to pkg-config which is not as well maintained and contains weird dependencies (Glib).

Explained:

ln -sf pkgconf /usr/bin/pkg-config ---> We need to symlink to pkg-config for us to use is in scripts.

ln -s /usr/lib/pkgconfig /usr/lib64/pkgconfig ---> We need to symlink lib64/pkgconfig to lib/pkgconfig to make it detectable.

https://sites.google.com/site/fullycapable/

LibCap is a library that allows to limit the reach of the superuser. For example, you might not want to pass the right to change permissions on files to a program that shouldn't do that, even if it does need superuser. This Library allows you to do just that by making the kernel function available to the user.

Bison - GNU Project - Free Software Foundation

Bison allows you to generate C parsers, often used with #FLEX (to sanitise what you input into bison).

Needed by the kernel and GNU software.

networking:iproute2 [Wiki]

Iproute2 is the default network tool for linux, and with it, we will be connection our LFN to the network.

https://www.perl.org/get.html

Perl is a high-level language (like python...) that fell out of favour, it's needed everywhere... and Openssl.

Explained:

ln -s gcc /bin/cc ---> Perl will use cc instead of gcc, we can bridge this with a symlink.

./Configure -d ---> Perl is a bit fancy in their configure script, -d is for default as you will need to answer 1000 things otherwise. When it asks you a question just press enter.

https://github.com/openssl/openssl

We need a library that will manage ours certificates for SSL,TLS,HTTPS. OpenSSL is the standard for that.

https://www.gnu.org/software/wget/

Wget will allow us to start downloading thing.

Explained:

--with-ssl=openssl ---> Use OpenSSL instead of GnuTLS.

Dnsmasq - network services for small networks.

DNSMasq is a small DNS server, it can be used for a bunch of other things and it was more widely used before systemd was the solution to everything (; .

We need a bit more setup in order to get DNSMasq to work, we need to create our first user, root:

Content of the file

here is what it means:

While we are making files lets create /etc/resolv.conf. This file is looked at when it comes time to choose a DNS, we will be choosing the one from cloudflare.

Content of /etc/resolv.conf:

Lets add ip/DNSMasq to our init.

This is the content:

Explained:

ip link set up eth0 ---> Default network connector eth0 set to up (enabled).

ip addr add 10.0.2.15/24 dev eth0 ---> Default guest (local) ip address for QEMU, applied to eth0.

ip route add 10.0.2.2 dev eth0 ---> Opens a route through 10.0.2.2 which is the QEMU gateway, applied to eth0.

ip route add 0/0 via 10.0.2.2 dev eth0 ---> Push all network traffic (0/0) via 10.0.2.2, applied to eth0.

dnsmasq -uroot ---> Start dnsmasq using the root user.

Lets Sync and reboot.

Once we boot it back up, our LFN should be able to go online.

We still need a certificate for us to accept https connections.

Explained:

mkdir -p /etc/ssl/certs ---> the -p allows all dirs that are not yet created to be created, so here we will be creating both /etc/ssl and /etc/ssl/certs

wget https://curl.se/ca/cacert.pem ---> wget allow to download from the internet, here we are downloading the CA root certificate.

--no-check-certificate ---> Ignores the fact that we cannot verify the https (as the root cert isn't installed yet).

mv cacert.pem ca-certificates.crt ---> Some program needs the cert to be of a specific name.

Lets edit the init again:

This is the content:

Explained:

SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt ---> This is the default variable and placement for a certificate.

Lets Sync and reboot to test it!

You can now use wget as much as you want!

Lets get python with pip working on LFN along with Ninja and Meson which are used to compile some software.

Python is an essential tool for any modern system, used for everything from system administration scripts to running complex applications. We will install Python 3 from source, ensuring it's linked correctly with the libraries we've already built.

Before we can build Python, we need one more library: libffi. The Foreign Function Interface library provides a way for a program written in one language to call code written in another. Python uses it for its powerful ctypes module.

With the prerequisite installed, we can now build Python itself. We'll use several configuration flags to make sure our Python build is optimized and can find the libraries we've already installed, like OpenSSL and libffi.

Explained:

--with-openssl=/usr ---> Explicitly tells Python where to find the OpenSSL headers and libraries. This enables the ssl module.

ln -s python3 /usr/bin/python ---> Both python and pip symlink need to be created to their 3 equivalent.

pip install setuptools ---> pip is a python package manager and it allows us to install setuptools which is needed by meson.

Meson is a build system, but it relies on a "backend" to do the actual compiling. The most common backend is Ninja, a small and extremely fast build tool. We'll need to install both.

Ninja is written in C++ and has a very straightforward build process.

Explained:

./configure.py --bootstrap ---> Ninja is unique in that it can build itself. This command uses Python to create a minimal build.ninja file and then uses a pre-compiled version of itself (or a C++ compiler) to build the final binary.

--verbose ---> Will crash if we don't, we are probably missing something but couldn't diag the issue XD.

cp ninja /usr/bin/ ---> We manually copy the single ninja executable into /usr/bin so it can be found by Meson.

Meson is a Python application, so we don't need to compile it in the traditional sense. We just need to download it and run its installation script.

Explained:

python setup.py install ---> This is a standard way to install Python packages from source. It will place the meson executable in /usr/bin and its library files in the correct Python site-packages directory.

We still need to edit the top line of meson as it won't correctly detect python:

This is the what the first line should look like:

Lets Sync and reboot to test it!

You now have a working Python, pip, Ninja Meson setup inside LFN!

Now that we have a basic system, let's create a non-root user for our daily tasks and install sudo to grant administrative privileges when needed. This is a crucial step for system security.

We need to install libxcrypt to provide the crypt() function required by the shadow utilities for password management.

Explained:

--enable-obsolete-api=no ---> Disable obsolete api, which isn't needed for a modern kernel.

https://gitlab.gnome.org/GNOME/libxml2

Libxml2 is an XML toolkit implemented in C. Needed to compile Linux-PAM.

Explained:

ln -s libxml2.so /usr/lib/libxml2.so.2 ---> Some programs we have compiled requires us to have the lib named that way.

Pluggable Authentication Modules for Linux is a crucial system component that provides a flexible framework for applications to authenticate users.

Explained:

wget http://docbook.org/xml/5.0/rng/docbookxi.rng ---> we need to bypass an internal test so it doesn't fail.

meson setup .. --prefix=/usr ---> The meson equivalent to ./configure.

-Ddocbook-rng=/LFN/Linux-PAM-1.7.1/build/docbookxi.rng ---> Same as wget...

meson compile ---> The meson equivalent to make.

meson install ---> The meson equivalent to make install.

We need to do some extra setup for PAM to work:

Here is the content:

The file sets default rules for the four main PAM management groups, each handled by the standard pam_unix.so module, which provides traditional Unix-style authentication based on files like /etc/passwd and /etc/shadow

Shadow - Utilities for managing accounts and shadow password files Shadow is a suite of tools that includes useradd, groupadd, passwd, and other essential utilities for managing user accounts.

Explained:

--without-libbsd ---> Do not use the readpassphrase function from libbsd which is not in LFN. Use the internal copy instead.

Now, let's create a user and a password for us.

Explained:

useradd ---> Creates a new user.

-m ---> Creates a home directory for the user at

/home/your_username. -s /bin/bash ---> Sets the default shell for this user to be bash.

passwd ---> Allows you to set a password for the new user and root (might be useful).

touch /etc/shadow ---> Needed to change root password

Sudo

Sudo allows a permitted user to execute a command as the superuser or another user, as specified by the security policy.

Explained:

--with-editor=/usr/bin/nano ---> Set the default text editor as nano (for visudo).

To allow our new user to use sudo, we need to edit the sudoers file. The visudo command is the recommended way to do this, as it prevents syntax errors.

Uncomment the following line at end of file.

Now lets add our user to wheel group to have access to sudo.

Let's modify our init script to log in as our new user automatically.

New content:

Explained:

mkdir /dev/pts ---> Creates the mount point /dev/pts.

mount -t devpts devpts /dev/pts ---> Mounts a Unix98 Pseudo terminal (PTY). Is used by sudo.

while true; do ---> Infinite loop.

/sbin/agetty --noclear tty1 ---> agetty will connect us to a terminal (tty1) and ask for a user+password. Once entered it will issues /bin/login to the user we selected letting us control of the terminal.

sleep 1 ---> Sleep (wait) for 1 second.

done ---> End to our loop.

This allows us to leave our session and enter another without kernel panic. you can do that by doing (CTRL+D)

/tmp needs to have specific permissions:

Explained:

chmod ---> Used to change the permission of a file/dir.

1777 ---> 777 Means that everybody will be able to write to the dir. the 1 is the sticky bit that only allows the owner of the dir (root) to edit it, meaning that only root can remove /tmp.

/etc/nsswitch.conf governs where/how a program should check for a ressource.

Here is the content:

Sync your changes and reboot in your new user.

Once reboot, we need to make a .bashrc file for our variables to be declared.

Here is the content:

Explained:

alias sudo='sudo -S' ---> When we do sudo it will instead use sudo -S. This is necessary as we need to get the password from standard input.

We also need to create .bash_profile:

Here is the content:

Explained:

If the shell is interactive and .bashrc exists, get the aliases and functions.

Sync your changes and reboot.

You should be able to log yourself in as your user or root with a working sudo.

https://cmake.org/

We have meson, lets get yet another build system script generator.

Autoconf - GNU Project - Free Software Foundation

Allows to create makefiles.

https://github.com/curl/curl/

Used to download everything... and Git. If you have a program, it will most likely use curl to download things.

Explained:

--with-openssl ---> Using OpenSSL as the SSL provider.

--without-libpsl ---> We don't have libpsl. Lets disable it.

https://github.com/git/git

Git, we all know what it is by now.

Explained:

make configure ---> Will allow up to generate a configure script.

./configure --prefix=/usr ---> git is special as the configure script cannot be used outside of its directory.

It's time to move beyond the console and lay the groundwork for a graphical user interface with the X Window System (Xorg).

We will now be expecting to use the new user (in /home/your_user) we have created, do not run everything as root.

X.Org

The Xorg server is the core of the X Window System, providing the basic framework for a GUI environment. Installing it involves compiling the server itself and several required libraries. This is a significant step and will involve compiling multiple packages.

https://freetype.org/

Allows to render fonts.

https://www.gnu.org/software/gperf/

GNU gperf is a perfect hash function generator. Needed by Fontconfig.

https://www.freedesktop.org/wiki/Software/fontconfig/

Fontconfig is a library for configuring and customizing font access.

Explained:

--enable-libxml2 ---> Fontconfig need an xml parser, the default is expat but we already have libxml2.

https://gitlab.freedesktop.org/xorg/proto/xorgproto

Contains the headers needed by other xorg component.

https://gitlab.freedesktop.org/xorg/lib/libxau

Explained:

wget ... ---> You can write the start of a command and do PAGE_UP for it to autocomplete the last command you have used, this can be very useful.

https://xcb.freedesktop.org/

The X protocol C-language Binding (XCB). Allows the client side to be implemented. We will need to install the xcb-proto then libxcb.

https://www.x.org/releases/X11R7.5/doc/xtrans/Xtrans.html

X Transport Interface. API that govern all Xorg component.

https://gitlab.freedesktop.org/xorg/lib/libx11

Core X11 Library.

https://gitlab.freedesktop.org/xorg/lib/libxkbfile

libxkbfile is used by the X servers and utilities to parse the XKB configuration data files.

https://gitlab.freedesktop.org/xorg/app/xkbcomp

X Keyboard Extension.

https://www.pixman.org/

Pixman is a low-level software library for pixel manipulation, providing features such as image compositing and trapezoid rasterization.

https://gitlab.freedesktop.org/mesa/libdrm

libdrm is a userspace library for accessing the DRM(Direct Rendering Manager). Made by Mesa.

GLSLang is the official reference front-end compiler and validator for the OpenGL ES, OpenGL, and Vulkan shading languages, particularly GLSL (OpenGL Shading Language). Required by Mesa.

Explained:

cmake .. ---> Just like meson setup .. but for cmake.

-DCMAKE_INSTALL_PREFIX=/usr ---> just like --prefix=/usr but for cmake.

https://mesa3d.org/

Mesa is the base for most graphic driver on linux.

Explained:

packaging Mako ---> Dependencies to compile mesa

--buildtype=release ---> Will create an optimized version. The compiled size will be far smaller.

-Dplatforms=x11,wayland ---> Compile for both X11 and Wayland.

-Dgallium-drivers=auto ---> Compile all possible gallium (Standard API for GPU drivers) drivers.

-Dvulkan-drivers=auto ---> Compile all possible Vulkan drivers

-Dvalgrind=disabled ---> Debugging tool that we don't have.

-Dvideo-codecs=all ---> Include all codecs.

-Dlibunwind=disabled ---> We don't have Libunwind so we disable it.

https://x.org/

The big man.

Explained:

--enable-xorg ---> This enables the building of the Xorg server.

We need a driver that will connect to our graphic card.

Now, to start our graphical environment, we will use the startx command. Let's create a basic .xinitrc file in our user's home directory.

Add the following content:

Make it executable:

After a reboot, you can try running startx. You should see a blank screen with a single xterm window. Congratulations, you have a graphical environment! To exit, type exit in the xterm window.

With Xorg installed, we can now build a basic but functional desktop environment. We'll install a tiling window manager, a terminal emulator, and an application launcher.

i3 - a tiling window manager i3 is a popular, lightweight, and highly configurable tiling window manager.

dmenu - dynamic menu dmenu is a fast and lightweight dynamic menu for X, often used with i3 to launch applications.

Now, let's update our ~/.xinitrc to start i3.

Replace the content with:

After a reboot and running startx, you will be greeted with the i3 initial configuration dialog. You can accept the defaults. You now have a tiling window manager! You can open a terminal by pressing Mod+Enter (the Mod key is usually the Windows key). You can launch applications by pressing Mod+d to open dmenu.

https://www.linuxfromscratch.org/lfs/view/stable/index.html