Supplemental Linux From Scratch (System V Edition)

https://glfs-book.github.io/slfs
Admin
This book is dedicated to supplementing an LFS, MLFS, BLFS, and/or GLFS x86_64 system by providing...
Tokens:71,715
Snippets:937
Trust Score:8.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install libime Documentation

Source: https://glfs-book.github.io/slfs/general/libime

This command installs the generated libime documentation into the system's documentation directory. It requires root privileges and ensures the documentation files are placed in a structured location.

```bash
install -v -m755 -d /usr/share/doc/libime-1.1.12 &&
cp -rv doc/html/* /usr/share/doc/libime-1.1.12
```

--------------------------------

### Compile and Install htop

Source: https://glfs-book.github.io/slfs/general/htop

This snippet shows the standard commands to configure, compile, and install the htop package. It first runs the configure script with a specified prefix, then makes the package, and finally installs it as the root user. Ensure you have the necessary build tools installed.

```bash
./configure --prefix=/usr &&
make

```

```bash
make install
```

--------------------------------

### Install FluidSynth and Copy Configuration

Source: https://glfs-book.github.io/slfs/general/fluidsynth

This command installs the compiled FluidSynth package to the system and copies the default configuration file to the appropriate directory. This step requires root privileges.

```bash
ninja install &&
cp -v fluidsynth.conf /etc/fluidsynth
```

--------------------------------

### Build and Install Fcitx5-Qt using CMake

Source: https://glfs-book.github.io/slfs/graph/fcitx5-qt

This snippet demonstrates how to configure, build, and install the Fcitx5-Qt package. It uses CMake with specific flags to define installation paths, build type, and Qt version support. The commands first create a build directory, then run CMake for configuration, followed by `make` for building and `make install` as the root user.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr   \
      -D CMAKE_BUILD_TYPE=Release    \
      -D CMAKE_SKIP_INSTALL_RPATH=ON \
      -D ENABLE_QT4=OFF              \
      -D ENABLE_QT5=OFF              \
      -D ENABLE_QT6=ON               \
      -Wno-dev .. &&

make
```

```bash
make install
```

--------------------------------

### Build and Install wf-config using Meson and Ninja

Source: https://glfs-book.github.io/slfs/wm/wf-config

This snippet demonstrates the standard procedure for building and installing the wf-config package. It involves creating a build directory, setting up the build with Meson specifying installation prefix and build type, and then compiling with Ninja. The installation is performed as the root user.

```shell
mkdir build &&
cd    build &&

meson setup --prefix=/usr       \
            --buildtype=release \
            -D tests=disabled   \
            ..

ninja
```

```shell
ninja install
```

--------------------------------

### Install glaze C++ Library with CMake

Source: https://glfs-book.github.io/slfs/general/glaze

This code snippet demonstrates the installation process for the glaze C++ library using CMake and Ninja. It involves creating a build directory, configuring the build with specific options such as disabling examples, developer mode, and fuzzing, and then building the project. The installation is performed as the root user.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr \
      -D CMAKE_BUILD_TYPE=Release  \
      -D glaze_BUILD_EXAMPLES=OFF  \
      -D glaze_DEVELOPER_MODE=OFF  \
      -D glaze_ENABLE_FUZZING=OFF  \
      -G Ninja .. &&

ninja
```

```bash
ninja install
```

--------------------------------

### Configure and Build libime with CMake

Source: https://glfs-book.github.io/slfs/general/libime

This sequence of commands prepares the build environment for libime. It creates a build directory, navigates into it, and then runs CMake with specific configuration options. Finally, it compiles the project using 'make'.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr   \
      -D CMAKE_BUILD_TYPE=Release    \
      -D CMAKE_SKIP_INSTALL_RPATH=ON \
      -D BUILD_SHARED_LIBS=ON        \
      -D ENABLE_TEST=OFF             \
      -Wno-dev .. &&

make
```

--------------------------------

### Install asio C++ Library

Source: https://glfs-book.github.io/slfs/general/asio

Commands to compile and install the asio C++ networking library. This process involves changing the directory, reconfiguring the build system, configuring installation paths, compiling the library, and finally installing it. A check is also performed to test the installation.

```bash
cd asio &&
autoreconf -fi &&
./configure --prefix=/usr &&
make
```

```bash
make check
```

```bash
make install
```

--------------------------------

### Install heirloom-ng and Clean Up Binaries

Source: https://glfs-book.github.io/slfs/svr4/heirloom-ng

This section covers the final steps of installing heirloom-ng and cleaning up redundant binaries. First, `make install` is executed as the `root` user to install the package. Subsequently, `rm -vf` is used by root to remove duplicate binaries (`/usr/5bin/col`, `/usr/5bin/what`) that are also provided by `heirloom-doctools` and `heirloom-devtools`.

```shell
make install

```

```shell
rm -vf /usr/5bin/col /usr/5bin/what

```

--------------------------------

### Build and Install foot Terminal Emulator

Source: https://glfs-book.github.io/slfs/graph/foot

This snippet demonstrates the commands to build and install the 'foot' Wayland terminal emulator. It involves creating a build directory, configuring the build with Meson, compiling the source code with Ninja, and finally installing the package. Ensure you have the necessary build tools and dependencies installed.

```bash
mkdir build &&
cd    build &&

meson setup --prefix=/usr --buildtype=release .. &&
ninja
```

```bash
ninja install
```

```bash
mv -v /usr/share/doc/foot{,-1.25.0}
```

--------------------------------

### Build Fcitx5 using CMake and Make

Source: https://glfs-book.github.io/slfs/graph/fcitx5

Compiles the Fcitx5 package using CMake for configuration and Make for the build process. This snippet assumes the build directory has been created and navigated into. It configures the installation prefix, build type, skips rpath, and disables testing. An internet connection and potentially system certificate setup are required.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr   \
      -D CMAKE_BUILD_TYPE=Release    \
      -D CMAKE_SKIP_INSTALL_RPATH=ON \
      -D ENABLE_TEST=OFF             \
      -Wno-dev .. &&

make
```

--------------------------------

### Install OpenJDK 17.0.17-ga

Source: https://glfs-book.github.io/slfs/general/openjdk

Installs the built OpenJDK 17.0.17-ga package. It creates a directory, copies the built images, sets ownership, and installs application icons for different sizes. This command should be run as the 'root' user.

```bash
install -vdm755 /opt/jdk-17.0.17-ga &&
cp -Rv build/*/images/jdk/* /opt/jdk-17.0.17-ga &&
chown -R root:root /opt/jdk-17.0.17-ga &&
for s in 16 24 32 48; do
  install -vDm644 src/java.desktop/unix/classes/sun/awt/X11/java-icon${s}.png \
                  /usr/share/icons/hicolor/${s}x${s}/apps/java.png
done
```

--------------------------------

### Install Mesa-Demos with Binary Renaming

Source: https://glfs-book.github.io/slfs/graph/mesa-demos

Performs a staged installation of Mesa-Demos and renames conflicting binaries to prevent conflicts with other packages. This ensures that utilities like 'identity', 'linktest', and 'poly' are installed as 'mesa-identity', 'mesa-linktest', and 'mesa-poly' respectively.

```bash
DESTDIR=$PWD/DESTDIR ninja install &&
for bin in {identity,linktest,poly}; do
  mv -v DESTDIR/usr/bin/{$bin,mesa-$bin}
done
```

--------------------------------

### Selective Installation of Mesa-Demos Utilities

Source: https://glfs-book.github.io/slfs/graph/mesa-demos

Installs only the essential utilities and important demos from Mesa-Demos as the root user. This command iterates through a predefined list of utilities and installs them into the system's binary directory, while also copying shared data.

```bash
mesa_utils=(
  eglgears_wayland
  eglgears_x11
  eglinfo
  eglkms
  egltri_wayland
  egltri_x11
  es1_info
  es2_info
  es2gears_wayland
  es2gears_x11
  es2tri
  gears
  glxgears
  glxinfo
  peglgears
  tri
  vkgears
  xeglgears
)
for util in ${mesa_utils[@]};
  install -vm755 DESTDIR/usr/bin/$util /usr/bin
done
cp -vR DESTDIR/usr/share/* /usr/share
```

--------------------------------

### Configure Fcitx5 Autostart

Source: https://glfs-book.github.io/slfs/graph/fcitx5

Sets up Fcitx5 to start automatically for a user upon login. This involves creating the autostart directory if it doesn't exist and copying the Fcitx5 desktop entry file into it. This command should be run as the individual user.

```bash
mkdir -p ~/.config/autostart &&
cp /usr/share/applications/org.fcitx.Fcitx5.desktop \
         ~/.config/autostart
```

--------------------------------

### Install Fcitx5 Documentation

Source: https://glfs-book.github.io/slfs/graph/fcitx5

Installs the generated Fcitx5 documentation into the system's documentation directory. This command requires root privileges and should only be run if the documentation was built previously. It creates the target directory and copies the HTML documentation files.

```bash
install -v -m755 -d /usr/share/doc/fcitx5-5.1.16 &&
cp -rv doc/html/* /usr/share/doc/fcitx5-5.1.16
```

--------------------------------

### Compile and Install xeyes

Source: https://glfs-book.github.io/slfs/graph/xeyes

This snippet shows the commands to compile and install the xeyes package. It requires Xorg Libraries and uses standard build tools like configure and make. The installation is performed in two steps: first, building the package, and then installing it as the root user.

```shell
./configure $XORG_CONFIG &&
make

```

```shell
make install
```

--------------------------------

### Build and Install i3 Window Manager

Source: https://glfs-book.github.io/slfs/wm/i3-wm

Commands to build and install the i3 window manager. It first creates a build directory, configures the build using Meson with a specified installation prefix and build type, and then compiles the package using Ninja. Finally, it installs the package as the root user and version-tags the documentation directory.

```bash
mkdir build &&
cd    build &&

meson setup ..          \
    --prefix=/usr       \
    --buildtype=release &&

ninja
```

```bash
ninja install &&
mv -v /usr/share/doc/i3{,-4.24}
```

--------------------------------

### Install All Mesa-Demos Binaries and Data

Source: https://glfs-book.github.io/slfs/graph/mesa-demos

Installs all available demos and binaries from the Mesa-Demos package into the system as the root user. This command copies the entire contents of the DESTDIR build output to the system's root directory, ensuring all built components are installed.

```bash
cp -vR DESTDIR/usr/* /usr
```

--------------------------------

### Build and Install libliftoff (Shell)

Source: https://glfs-book.github.io/slfs/general/libliftoff

This snippet shows the commands to build and install the libliftoff library. It first creates a build directory, configures the build using Meson with release optimizations, and then compiles the library with Ninja. Finally, it installs the library as the root user.

```shell
mkdir build &&
cd    build &&

meson setup --prefix=/usr --buildtype=release .. &&
ninja
```

```shell
ninja install
```

--------------------------------

### Install G-Kermit as Root User

Source: https://glfs-book.github.io/slfs/general/gkermit

This command installs the G-Kermit package system-wide after it has been built. It specifies installation directories for binaries, man pages, and documentation. Finally, it renames the man page file to conform to the standard 'gkermit.1' format.

```bash
make BINDIR=/usr/bin MANDIR=/usr/share/man/man1 \
     TEXTDIR=/usr/share/doc/gkermit-2.01 install &&
mv -v /usr/share/man/man1/gkermit.l /usr/share/man/man1/gkermit.1
```

--------------------------------

### Build and Install imv with Meson and Ninja

Source: https://glfs-book.github.io/slfs/general/imv

Configures, builds, and installs the imv image viewer using Meson and Ninja. Key build options include specifying the installation prefix, libexec directory, build type, and enabling/disabling specific features like Wayland/X11 support and Unicode backend.

```bash
mkdir build &&
cd    build &&

meson setup ..                  \
      --prefix=/usr             \
      --libexecdir=/usr/libexec \
      --buildtype=release       \
      -D windows=all            \
      -D unicode=icu            \
      -D test=disabled          \
      -D contrib-commands=false &&

ninja
```

```bash
ninja install
```

--------------------------------

### Build and Install MelonDS using CMake and Ninja

Source: https://glfs-book.github.io/slfs/emu/melonds

This snippet outlines the commands to build and install the MelonDS NDS emulator. It first creates a build directory, configures the build with CMake specifying installation prefix and build type, then compiles the project using Ninja. Finally, it installs the emulator as the root user.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr   \
      -D CMAKE_BUILD_TYPE=Release    \
      -G Ninja .. &&

ninja
```

```bash
ninja install
```

--------------------------------

### Install FluidSynth SoundFonts

Source: https://glfs-book.github.io/slfs/general/fluidsynth

This command unpacks and installs the recommended SoundFont files into the system's soundfonts directory. These files are necessary for FluidSynth to provide instrumentals during MIDI playback. This step requires root privileges.

```bash
tar -xf ../../fluid-soundfont_3.1.orig.tar.gz &&
install -vdm755 /usr/share/soundfonts         &&
install -vm644  fluid-soundfont-3.1/*.sf2 /usr/share/soundfonts
```

--------------------------------

### Install Rofi 2.0.0 Build and Installation

Source: https://glfs-book.github.io/slfs/graph/rofi

This snippet outlines the steps to build and install Rofi 2.0.0. It includes creating a build directory, configuring with Meson, compiling with Ninja, and finally installing the package as the root user. An internet connection is required for building.

```bash
mkdir build &&
cd    build &&

meson setup --prefix=/usr --buildtype=release .. &&
ninja

ninja install
```

--------------------------------

### Unpack GCEM Submodule with tar

Source: https://glfs-book.github.io/slfs/general/fluidsynth

This command unpacks the required GCEM submodule using the tar utility. It is a prerequisite step before proceeding with the FluidSynth installation.

```bash
tar -xf ../gcem-012ae73c6d0a2cb09ffe86475f5c6fba3926e200.tar.gz &&
mv -T gcem-012ae73c6d0a2cb09ffe86475f5c6fba3926e200 gcem
```

--------------------------------

### Install OpenTTD and Update Documentation Path

Source: https://glfs-book.github.io/slfs/gaming/openttd

This code block demonstrates the commands to install the compiled OpenTTD application and then move its documentation directory to a version-specific path. These commands should be executed as the 'root' user. The 'ninja install' command installs the program, and the 'mv' command renames the documentation directory to include the version number for better organization.

```shell
ninja install &&
mv -v /usr/share/doc/openttd{,-15.0-beta3}
```

--------------------------------

### Build and Install eza Executable (Rust)

Source: https://glfs-book.github.io/slfs/general/eza

Builds the eza package in release mode using Cargo and installs the executable to /usr/bin/. Requires Rustc to be installed. The system certificate store might need setup before building.

```bash
cargo build --release
install -vDm755 target/release/eza -t /usr/bin/
```

--------------------------------

### Build and Install Hypr Libraries (Bash)

Source: https://glfs-book.github.io/slfs/wm/hyprlib

This bash script iterates through the downloaded Hypr library archives, extracts them, builds them using either Meson or CMake based on the package name, and installs them using root privileges. It also handles post-installation cleanup and library cache updates.

```bash
for package in $(grep -v '^#' ../hypr-list)
do
package=$(basename "$package")
packagedir=${package%.tar.?z*}
packagedir=$(echo -n "$packagedir" | sed 's/-v\([0-9]\)/-\1/')
echo "Building $packagedir"

  tar -xf $package
  pushd $packagedir

  case $packagedir in
    hyprland-protocols-[0-9]* ) 
      mkdir build
      cd build
        meson setup --prefix=/usr ..
    ;; 

    * ) 
      mkdir build
      cd    build
        cmake -D CMAKE_INSTALL_PREFIX=/usr       \
              -D CMAKE_BUILD_TYPE=Release        \
              -D CMAKE_SKIP_INSTALL_RPATH=ON     \
              -D INSTALL_QML_PREFIX=/lib/qt6/qml \
              -D DISABLE_TESTS=ON                \
              -D BUILD_TESTING=OFF               \
              -W no-dev -G Ninja ..
    ;; 
  esac

  ninja
  as_root ninja install
  popd
  rm -rf $packagedir
  as_root /sbin/ldconfig
done
```

--------------------------------

### Install Mbed TLS using CMake and Ninja

Source: https://glfs-book.github.io/slfs/general/mbedtls

This snippet demonstrates the build and installation process for Mbed TLS. It first creates a build directory, configures the build with CMake specifying installation prefix, build type, and library options, and then builds the project using Ninja. The second part involves installing the built components to a DESTDIR, renaming executables to avoid conflicts, and finally copying the installed files to the system's /usr directory.

```shell
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr      \
      -D CMAKE_BUILD_TYPE=Release       \
      -D CMAKE_SKIP_RPATH=ON            \
      -D USE_SHARED_MBEDTLS_LIBRARY=ON  \
      -D USE_STATIC_MBEDTLS_LIBRARY=OFF \
      -D ENABLE_TESTING=OFF             \
      -G Ninja .. &&

ninja
```

```shell
DESTDIR=$PWD/DESTDIR ninja install &&
pushd DESTDIR/usr/bin &&
  for i in *; do
    mv -v {,mbedtls_}$i
  done
popd &&
cp -vR DESTDIR/usr/* /usr
```

--------------------------------

### Build and Install xcb-imdkit using CMake

Source: https://glfs-book.github.io/slfs/graph/xcb-imdkit

This snippet demonstrates the build and installation process for xcb-imdkit. It utilizes CMake for configuration, specifying installation paths and build types, followed by make commands for compilation and installation. Ensure all dependencies are met before running these commands.

```shell
mkdir build && cd build &&
cmake -D CMAKE_INSTALL_PREFIX=/usr   \
      -D CMAKE_BUILD_TYPE=Release    \
      -D CMAKE_SKIP_INSTALL_RPATH=ON \
      -Wno-dev .. &&
make

make install
```

--------------------------------

### Apply Patch for Mesa-Demos

Source: https://glfs-book.github.io/slfs/graph/mesa-demos

Applies a system data patch to the Mesa-Demos source code. This patch is necessary for ensuring shaders and other required data are correctly copied during the installation process. It takes the patch file path as input.

```bash
patch -Np1 -i ../mesa-demos-system-data.patch
```

--------------------------------

### Test C and C++ Compiler Installation

Source: https://glfs-book.github.io/slfs/general/gnat

Verifies the installation of C and C++ compilers by creating simple 'hello world' programs, compiling them with gcc and g++, and executing the resulting binaries. It tests both standard compilation and 32-bit and x32-bit multilib support.

```bash
echo "int main(){}" > main.c &&
cp -v main.c main.cpp &&
gcc main.c            &&
./a.out               &&

rm -v a.out           &&
g++ main.cpp          &&
./a.out               &&

rm -v a.out main.{c,cpp}
```

```bash
echo "int main(){}" > main.c &&
cp -v main.c main.cpp &&
gcc -m32 main.c       &&
./a.out               &&

rm -v a.out           &&
g++ -m32 main.cpp     &&
./a.out               &&

rm -v a.out main.{c,cpp}
```

```bash
echo "int main(){}" > main.c &&
cp -v main.c main.cpp &&
gcc -mx32 main.c      &&
./a.out               &&

rm -v a.out           &&
g++ -mx32 main.cpp    &&
./a.out               &&

rm -v a.out main.{c,cpp}
```

--------------------------------

### Configure and Build FluidSynth with CMake and Ninja

Source: https://glfs-book.github.io/slfs/general/fluidsynth

These commands set up the build environment for FluidSynth using CMake and then compile the project with Ninja. It includes configuring installation paths, build type, and specific FluidSynth daemon environment file.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr             \
      -D CMAKE_BUILD_TYPE=Release              \
      -D CMAKE_SKIP_INSTALL_RPATH=ON           \
      -D FLUID_DAEMON_ENV_FILE=/etc/fluidsynth \
      -W no-dev -G Ninja .. &&
ninja
```

--------------------------------

### Build libvpl-tools with CMake and Make

Source: https://glfs-book.github.io/slfs/graph/libvpl-tools

This sequence of commands builds the libvpl-tools package. It starts by creating a build directory, navigating into it, and then configuring the build using CMake with specific installation and build type options. Finally, it compiles the package using 'make'.

```bash
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr     \
      -D CMAKE_BUILD_TYPE=Release      \
      -D CMAKE_SKIP_INSTALL_RPATH=ON   \
      -D BUILD_TESTS=ON                \
      -W no-dev ..                     &&
make
```

--------------------------------

### Configure and Build enet (Shell)

Source: https://glfs-book.github.io/slfs/general/enet

Installs the enet package by first configuring the build environment using './configure' and then compiling the source code with 'make'. This process prepares the library for installation.

```shell
./configure --prefix=/usr --disable-static &&
make
```

--------------------------------

### Configure and Build libdatachannel with CMake and Ninja

Source: https://glfs-book.github.io/slfs/general/libdatachannel

Configures the libdatachannel build using CMake with specific options and then builds the project using Ninja. Options include installation prefix, build type, disabling rpath, and controlling the use of optional/system dependencies.

```shell
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr        \
      -D CMAKE_BUILD_TYPE=Release         \
      -D CMAKE_SKIP_INSTALL_RPATH=ON      \
      -D USE_GNUTLS=0                     \
      -D USE_NICE=0                       \
      -D USE_SYSTEM_JUICE=1               \
      -D USE_SYSTEM_SRTP=1                \
      -D NO_EXAMPLES=1                    \
      -D NO_TESTS=1                       \
      -Wno-dev -G Ninja .. &&

ninja
```

--------------------------------

### Install mGBA and Update Documentation Directory

Source: https://glfs-book.github.io/slfs/emu/mgba

This snippet demonstrates the commands to install the compiled mGBA package and rename the documentation directory for version consistency. It requires root privileges for the installation.

```shell
ninja install &&
mv -v /usr/share/doc/mGBA{,-eeb52e}
```

--------------------------------

### Unpack libdatachannel Submodules

Source: https://glfs-book.github.io/slfs/general/libdatachannel

Extracts required submodules (plog and usrsctp) and moves them into the 'deps' directory. These are essential for the libdatachannel build process.

```shell
tar -xf ../94899e0b926ac1b0f4750bfbd495167b4a6ae9ef.tar.gz &&
tar -xf ../fec583d54493f879d2ae44a743423bf8a04371ab.tar.gz &&

mv -T plog-*    deps/plog &&
mv -T usrsctp-* deps/usrsctp
```

--------------------------------

### Compile and Build OpenTTD using CMake and Ninja

Source: https://glfs-book.github.io/slfs/gaming/openttd

This snippet details the commands to compile and build the OpenTTD package. It first creates a 'build' directory, changes into it, and then configures the build using CMake with specific flags for installation prefix and build type. Finally, it uses Ninja to perform the actual build process. Ensure you have CMake and Ninja installed before running these commands.

```shell
mkdir build &&
cd    build &&

cmake -D CMAKE_INSTALL_PREFIX=/usr   \
      -D CMAKE_BUILD_TYPE=Release    \
      -W no-dev -G Ninja .. &&

ninja
```

--------------------------------

### Configure CDE Display Manager Boot Script

Source: https://glfs-book.github.io/slfs/wm/cde-de

Sets up the necessary directories and installs the `xdm` boot script from `blfs-bootscripts` to automatically start the CDE display manager (`dtlogin`) on boot. It also configures the display manager options and adds it to the `inittab` file.

```bash
install -d -m 755 /etc/rc.d/rc{0,1,2,3,4,5,6,S}.d &&
install -d -m 755 /etc/rc.d/init.d &&
install -d -m 755 /etc/sysconfig &&
install -m 754 blfs/init.d/xdm        /etc/rc.d/init.d/ &&
install -m 644 blfs/sysconfig/xdm /etc/sysconfig/xdm &&
echo "DISPLAY_MANAGER=/usr/dt/bin/dtlogin" >> /etc/sysconfig/xdm &&
sed -i "s/DM_OPTIONS=.*/DM_OPTIONS=\"-quiet -daemon\"/g" /etc/sysconfig/xdm &&
if ! grep -q '^dm:5' /etc/inittab; then \
        echo dm:5:respawn:/etc/rc.d/init.d/xdm >> /etc/inittab; \
fi
```

--------------------------------

### Install wlr-randr using Meson and Ninja

Source: https://glfs-book.github.io/slfs/general/wlr-randr

This snippet details the process of building and installing the wlr-randr package. It involves creating a build directory, configuring the build with Meson, and then compiling and installing the package using Ninja. The `--prefix=/usr` and `--buildtype=release` flags are important for a standard installation.

```shell
mkdir build &&
cd    build &&

meson setup .. \
      --prefix=/usr \
      --buildtype=release &&

ninja
```

```shell
ninja install
```

--------------------------------

### Define Root Execution Function (Bash)

Source: https://glfs-book.github.io/slfs/wm/hyprlib

This bash function 'as_root' provides a robust way to execute commands with root privileges. It checks if the current user is root, otherwise it attempts to use 'sudo', falling back to 'su -c' if neither is available. This is crucial for installing packages system-wide.

```bash
as_root()
{
  if   [ $EUID = 0 ];        then $* 
  elif [ -x /usr/bin/sudo ]; then sudo $* 
  else                            su -c \"$*\"
  fi
}

export -f as_root
```

--------------------------------

### Install PrismLauncher with Ninja (Bash)

Source: https://glfs-book.github.io/slfs/gaming/prism-launcher

This command installs the PrismLauncher application after it has been successfully built. It uses the `ninja install` command, which is part of the Ninja build system, to copy the compiled files to their designated locations. This command requires root privileges.

```bash
ninja install
```

--------------------------------

### Build and Install libdecor using Meson and Ninja

Source: https://glfs-book.github.io/slfs/general/libdecor

This snippet demonstrates the process of building and installing the libdecor library. It involves creating a build directory, configuring the build with Meson, and then compiling and installing with Ninja. Key options like build type, demo inclusion, and GTK plugin are configurable.

```shell
mkdir build &&
cd    build &&

meson setup --prefix=/usr       \
            --buildtype=release \
            -D demo=false       \
            -D gtk=disabled     \
            ..

ninja
```

```shell
ninja install
```
Tokens:
Raw