What is Void Linux? An Introduction

Okay, here’s a comprehensive article on Void Linux, aiming for around 5000 words, covering its key features, philosophy, and usage:

What is Void Linux? An Introduction

Void Linux is a truly unique and independent Linux distribution. Unlike many distributions that are derivatives of Debian, Ubuntu, Arch Linux, or Fedora, Void was built from scratch. This independence is core to its philosophy and design, resulting in a system that is both minimalist and incredibly flexible. It’s not for the faint of heart or the absolute beginner, but for users who value control, simplicity, and a deep understanding of their operating system, Void offers a rewarding and powerful experience. This article will delve into the intricacies of Void Linux, exploring its history, core features, package management, installation, and common use cases. We’ll also discuss its advantages and disadvantages compared to other popular distributions.

1. A History of Independence: The Origins of Void

Void Linux was created in 2008 by Juan Romero Pardines, a former NetBSD developer. His motivation stemmed from a desire for a distribution that offered a rolling-release model (continuous updates without major version upgrades) combined with a clean, minimalist base system and a BSD-style init system. He also wanted a system free from the influence of systemd, which was gaining widespread adoption at the time but was (and still is) a point of contention within the Linux community.

The project started small, a testament to the power of independent development. It grew organically, attracting a community of developers and users who appreciated its core principles:

Simplicity: Avoid unnecessary complexity. Keep the base system lean and efficient.
Control: Give users maximum control over their system configuration.
Stability: Provide a stable, reliable platform despite the rolling-release nature.
Freedom: Offer a choice of init systems and other core components.

Over the years, Void has steadily gained popularity, not through aggressive marketing, but through word-of-mouth within the Linux community. Its reputation for stability, performance, and its unique package management system (XBPS) has cemented its place as a respected and well-regarded distribution.

2. Key Features and Distinguishing Characteristics

Void Linux stands out from the crowd due to a combination of features that are either unique or rarely found together in other distributions:

Runit Init System (Default): Unlike the vast majority of modern Linux distributions that use systemd, Void defaults to runit. Runit is a small, fast, and reliable init system that follows the Unix philosophy of “do one thing and do it well.” It’s known for its simplicity and ease of understanding, making service management straightforward. Runit uses simple shell scripts for service definitions, making them easy to read, modify, and debug.
XBPS Package Manager (X Binary Package System): XBPS is Void’s custom-built package manager, and it’s one of the distribution’s most significant strengths. It’s designed for speed, efficiency, and reliability. Key features of XBPS include:
- Binary Packages: XBPS uses pre-compiled binary packages, making installation and updates fast.
- Rolling Release: Void follows a rolling-release model, meaning you receive the latest software updates continuously without needing to perform major version upgrades. XBPS handles this process smoothly and efficiently.
- Atomic Transactions: XBPS performs package operations atomically. This means that either all changes are applied successfully, or none are. This prevents partial installations or broken systems in case of interruptions.
- Dependency Resolution: XBPS has robust dependency resolution, ensuring that all required libraries and components are installed correctly.
- XBPS-Src (Source Packages): While XBPS primarily uses binary packages, it also provides a powerful source package system called xbps-src. This allows users to build packages from source, customize them, and even create their own packages. xbps-src uses a simple, declarative build system that makes the process relatively straightforward.
- Cryptographic Verification: XBPS verifies the integrity and authenticity of packages using cryptographic signatures, protecting against malicious or corrupted packages.
- Local Repository Support: You can easily create and manage your own local repositories, useful for testing packages or sharing them within a local network.
musl libc (Optional, but Popular): Void offers both glibc (the standard GNU C Library) and musl libc versions. musl is a lightweight, standards-compliant C library designed for static linking and embedded systems. It’s known for its small footprint, speed, and security focus. Using musl can result in a smaller, faster, and potentially more secure system, although it may have compatibility issues with some software that relies heavily on glibc-specific features. The choice between glibc and musl is presented during installation.
Minimal Base System: Void’s base installation is incredibly minimal. It includes only the essential components needed to boot the system and access the package manager. This gives users complete control over what software is installed, avoiding unnecessary bloat.
No Systemd (by Default): As mentioned earlier, Void’s rejection of systemd is a defining characteristic. While systemd is now the de facto standard in many distributions, Void’s commitment to runit (and the option to use other init systems) appeals to users who prefer a simpler, more traditional approach to system management. However, it’s important to note that while systemd is not included by default, packages that depend on it can still be installed, and systemd can be used if desired, though it requires more manual configuration.
Choice of Desktop Environments: Void doesn’t force a specific desktop environment on users. You can choose from a wide range of options, including popular choices like Xfce, GNOME, KDE Plasma, MATE, Cinnamon, and LXQt, as well as more lightweight window managers like i3, Sway, Openbox, and Fluxbox. This flexibility allows users to tailor their desktop experience to their preferences.
Kernel Options: Void provides multiple kernel options, including the latest stable kernel, a long-term support (LTS) kernel, and a hardened kernel. This allows users to choose the kernel that best suits their needs, balancing stability, features, and security.
Active and Helpful Community: The Void Linux community is known for being knowledgeable, helpful, and welcoming. The forums, IRC channel, and subreddit are excellent resources for getting support, asking questions, and learning from other users.
Official Packages and void-packages: All official packages are maintained in the void-packages repository on Github, a monorepo that builds all the available packages for Void Linux.

3. Package Management with XBPS: A Deep Dive

XBPS is arguably the heart of Void Linux, and understanding its capabilities is crucial for effectively using the distribution. Let’s explore some of its key commands and features in more detail:

Basic Operations:
- xbps-install <package>: Installs one or more packages. For example, xbps-install firefox would install the Firefox web browser.
- xbps-remove <package>: Removes a package.
- xbps-query -Rs <search_term>: Searches for packages. The -Rs flags perform a remote search (in the online repositories) using a regular expression.
- xbps-query -Ss <search_term>: Searches for packages, showing a short description.
- xbps-query -l: Lists all installed packages.
- xbps-query -p <package>: Shows detailed information about an installed package.
- xbps-query -o <file>: Shows which package owns a specific file.
- xbps-update: Updates the local package database and upgrades all installed packages to their latest versions. This is a crucial command to run regularly.
- xbps-install -Su: This is a shorthand for updating the system. It combines synchronization of the package database (-S) with the update process (-u).
- xbps-remove -Oo: Removes orphaned packages (packages that were installed as dependencies but are no longer needed). This helps keep the system clean.
Working with Repositories:
- Void uses a system of repositories to distribute packages. The main repositories are:
  - current: The main repository containing the latest stable packages.
  - nonfree: Contains packages with non-free licenses (e.g., proprietary drivers).
  - multilib: (For 32-bit compatibility on 64-bit systems) Contains 32-bit libraries for running 32-bit applications.
  - multilib/nonfree: Combines multilib and nonfree.
- You can enable or disable repositories by editing the files in /etc/xbps.d/. These files are simple text files that list the repository URLs.
XBPS-Src: Building Packages from Source:
- xbps-src is a powerful tool for building packages from source. It uses a simple, declarative build system based on shell scripts.
- To use xbps-src, you first need to install the xtools package: xbps-install xtools.
- Then, you clone the void-packages repository: git clone https://github.com/void-linux/void-packages.
- The void-packages repository contains template files for each package, located in the srcpkgs directory.
- To build a package, you navigate to its directory within srcpkgs and run ./xbps-src pkg <package_name>.
- xbps-src handles dependency resolution, fetching source code, patching, compiling, and creating a binary package that can be installed with xbps-install.
- You can customize the build process by modifying the template file. This allows you to apply patches, change compilation flags, and more.
- xbps-src also supports cross-compilation, allowing you to build packages for different architectures.
Managing Configuration Files with xbps-pkgdb:
- Void Linux uses a special mechanism to manage configuration files that are part of packages. These are called “preserved” configuration files.
- When a package update includes changes to a preserved configuration file, XBPS does not automatically overwrite the existing file. Instead, it creates a new file with a .new extension.
- The xbps-pkgdb command is used to manage these files.
- xbps-pkgdb -m lists all modified configuration files.
- You can then manually compare the .new file with your existing configuration file and merge any desired changes. This prevents updates from breaking your custom configurations.
Using Virtual Packages:
- Virtual packages provide an abstraction layer for software functionality. Multiple real packages can provide a virtual package.
- For example the virtual package mail-mta can be provided by real packages like postfix, sendmail, etc.

4. Installation: A Step-by-Step Guide

Installing Void Linux is a bit more involved than installing distributions with graphical installers, but it’s not overly complex. It’s a text-based process that requires some familiarity with the command line.

Download the Installation Image:
- Go to the Void Linux website (voidlinux.org) and download the appropriate installation image.
- You’ll have several choices:
  - Base Image: A minimal image for installing a basic system.
  - Live Images: Images with pre-installed desktop environments (e.g., Xfce, MATE).
  - glibc or musl: Choose the C library you want to use.
  - Architecture: Select the correct architecture for your system (e.g., x86_64, i686, ARM).
Create Bootable Media:
- Use a tool like dd (on Linux/macOS) or Rufus (on Windows) to write the downloaded image to a USB drive or DVD.
Boot from the Installation Media:
- Insert the USB drive or DVD into your computer and boot from it. You may need to adjust your BIOS/UEFI settings to change the boot order.
Connect to the Internet (if needed):
- If you’re using a wired connection, you may be automatically connected.
- For Wi-Fi, you’ll need to use the command-line tools to connect. The wpa_supplicant and dhcpcd tools are commonly used. The Void Linux documentation provides detailed instructions on connecting to Wi-Fi.
Partition Your Disk:
- Use a partitioning tool like cfdisk, fdisk, or parted to create the necessary partitions on your hard drive. At a minimum, you’ll need:
  - A root partition (/)
  - A swap partition (optional, but recommended)
  - An EFI system partition (ESP) if you’re using UEFI (usually mounted at /boot/efi)
- Example using cfdisk:
  1. Run cfdisk /dev/sdX (replace sdX with the correct device name for your hard drive).
  2. Create a new partition table (GPT or DOS, depending on your system).
  3. Create the necessary partitions, setting their types appropriately (e.g., “Linux filesystem” for the root partition, “Linux swap” for the swap partition, “EFI System” for the ESP).
  4. Write the changes to the disk.
Format the Partitions:
- Format the partitions you created with the appropriate filesystems. Common choices include ext4 for the root partition and swap for the swap partition.
- Example:
  bash mkfs.ext4 /dev/sda1 # Format the root partition (replace sda1 with the correct partition) mkswap /dev/sda2 # Format the swap partition (replace sda2 with the correct partition) swapon /dev/sda2 # Enable the swap partition # If you have an EFI partition: mkfs.fat -F32 /dev/sda3 # Format the EFI partition (replace sda3)
Mount the Partitions:
- Mount the root partition to /mnt:
  bash mount /dev/sda1 /mnt
- Create any necessary directories and mount other partitions:
  bash mkdir -p /mnt/boot/efi # If you have an EFI partition mount /dev/sda3 /mnt/boot/efi # Mount the EFI partition
Install the Base System:
- Use the xbps-install command to install the base system:
  bash xbps-install -S -r /mnt -R <repository_url> base-system
  - -S: Synchronizes the package database.
  - -r /mnt: Specifies the root directory for the installation.
  - -R <repository_url>: Specifies the repository URL to use. You can find the appropriate URL on the Void Linux website or in the installation image’s documentation. You’ll likely need to specify a mirror close to your location for faster downloads.
  - base-system: This is a meta-package that includes the essential components of a Void Linux system.
Configure the System:
- Chroot into the New System:
  bash void-chroot /mnt
  This command changes the root directory to /mnt, effectively putting you “inside” the newly installed system.
- Set the Hostname:
  bash echo "myhostname" > /etc/hostname # Replace "myhostname" with your desired hostname
- Configure the Network:
  - Create the necessary configuration files in /etc/ to set up your network connection. The specific files and their contents will depend on your network configuration (static IP, DHCP, Wi-Fi). Refer to the Void Linux documentation for detailed instructions.
- Set the Root Password:
  bash passwd
- Create a User Account:
  bash useradd -m -G wheel <username> # Replace <username> with your desired username passwd <username>
  This creates a user account, adds it to the wheel group (which allows using sudo), and sets its password.
- Configure /etc/fstab:
- Edit /etc/fstab to automatically mount partitions on boot.
  nano /etc/fstab
- Use the blkid command to find the UUIDs of your partitions. An example /etc/fstab entry:
  UUID=<uuid_of_root_partition> / ext4 defaults 0 1 UUID=<uuid_of_swap_partition> swap swap defaults 0 0 UUID=<uuid_of_efi_partition> /boot/efi vfat defaults 0 2
- Install a Bootloader:
  - Void Linux commonly uses GRUB as the bootloader.
    “`bash
    xbps-install grub os-prober
  For UEFI systems:
  
  grub-install –target=x86_64-efi –efi-directory=/boot/efi –bootloader-id=Void
  
  For legacy BIOS systems:
  
  grub-install /dev/sda #Replace sda with the correct drive
  
  grub-mkconfig -o /boot/grub/grub.cfg
  “`
  This installs GRUB, configures it to detect other operating systems (if any), and generates the GRUB configuration file.
- Install Additional Packages (Optional):
- At this point you may choose to install additional packages such as a desktop environment:
  xbps-install xfce4 xfce4-goodies
- Exit Chroot and Reboot:
- Exit the chroot environment:
  bash exit
- Unmount the partitions:
  bash umount -R /mnt
- Reboot the system:
  bash reboot
Post-Installation Configuration:
- After rebooting, you’ll be greeted by the login prompt (either a text-based login or a graphical login if you installed a display manager).
- Log in with the user account you created.
- You can now continue configuring your system, installing additional software, and customizing your desktop environment (if you installed one).
- Remember to update your system regularly: sudo xbps-install -Su.

5. Common Use Cases and Who Should Use Void Linux

Void Linux is a versatile distribution suitable for a variety of use cases, but it’s particularly well-suited for:

Experienced Linux Users: Void requires a good understanding of Linux fundamentals and the command line. It’s not a distribution that holds your hand; it expects you to know what you’re doing.
Developers: The clean base system, rolling-release model, and powerful package management tools make Void an excellent choice for developers.
System Administrators: The stability, control, and flexibility of Void make it suitable for server deployments. The runit init system and the option to use musl libc can be particularly appealing for server environments.
Users Who Value Simplicity and Control: If you want a system that’s free from bloat and gives you maximum control over its configuration, Void is an excellent choice.
Users Who Prefer a Rolling-Release Model: If you want the latest software without the hassle of major version upgrades, Void’s rolling-release model is a great option.
Users Who Want to Learn More About Linux: Using Void Linux is a great way to learn more about the inner workings of a Linux system. You’ll be forced to understand how things work, which can be a valuable learning experience.
Embedded Systems (with musl): The musl libc version of Void is particularly well-suited for embedded systems due to its small footprint and focus on static linking.
Minimalist Desktop Environments: Void’s lack of a default desktop environment and minimal base system makes it ideal for creating custom, lightweight desktop setups.

Who Should Not Use Void Linux?

Beginners: If you’re new to Linux, Void is probably not the best choice. Distributions like Ubuntu, Linux Mint, or Fedora are more user-friendly for beginners.
Users Who Need a “Just Works” System: Void requires more manual configuration than many other distributions. If you need a system that works out of the box with minimal effort, Void may not be the best fit.
Users Who Rely on Specific Software with glibc Dependencies (and don’t want to use glibc): While many applications work fine with musl, some software may have dependencies on glibc-specific features. If you rely on such software and don’t want to use the glibc version of Void, you may encounter compatibility issues.
Users Who Are Uncomfortable with the Command Line: A significant portion of Void’s configuration and management is done through the command line. If you’re not comfortable with the command line, you’ll find Void challenging to use.

6. Advantages and Disadvantages of Void Linux

Advantages:

Speed and Performance: Void is known for its speed and performance, thanks to its lightweight base system, efficient package manager, and the option to use musl libc.
Rolling Release: Continuous updates mean you always have the latest software without major version upgrades.
Stability: Despite the rolling-release model, Void is surprisingly stable. The careful testing and quality control of packages contribute to this stability.
Flexibility and Control: Void gives users maximum control over their system configuration. You choose your init system, desktop environment, and other core components.
Minimalism: The clean base system avoids unnecessary bloat, resulting in a leaner and more efficient system.
XBPS Package Manager: XBPS is a fast, reliable, and feature-rich package manager.
Runit Init System: Runit is a simple, fast, and reliable alternative to systemd.
Active and Helpful Community: The Void Linux community is a valuable resource for support and information.
Excellent Documentation: Void has comprehensive and well-maintained documentation.
Source-Based Package Building (XBPS-Src): xbps-src provides a powerful and flexible way to build packages from source.

Disadvantages:

Steeper Learning Curve: Void is not as beginner-friendly as some other distributions. It requires more command-line knowledge and manual configuration.
Smaller Package Selection (Compared to Larger Distributions): While Void has a good selection of packages, it’s not as extensive as the package repositories of larger distributions like Debian or Arch Linux.
Potential Compatibility Issues (with musl): Some software may have compatibility issues with musl libc.
Less “Out-of-the-Box” Experience: Void requires more manual configuration than distributions with graphical installers and pre-configured desktop environments.
Relatively Smaller Community: While the Void community is active and helpful, it’s smaller than the communities of some of the more popular distributions. This can sometimes mean it takes a bit longer to find solutions to niche problems.

7. Comparison with Other Distributions

Let’s compare Void Linux to some other popular distributions:

Void vs. Arch Linux: Both are rolling-release distributions aimed at experienced users. Arch is known for its vast package repository (AUR) and its “Arch Way” philosophy of extreme simplicity and user-centricity. Void is similar in many ways but differs in its default use of runit (instead of systemd), its own package manager (XBPS instead of pacman), and a slightly more curated approach to its official repositories. Arch generally has a larger community and a wider selection of packages, especially in the AUR. Void tends to be slightly more stable and has a stronger focus on minimalism in its base system. The choice often comes down to personal preference regarding init systems and package management.
Void vs. Debian: Debian is known for its stability and its vast package selection. It offers both stable and testing releases. Debian uses systemd by default and the APT package manager. Void is a rolling-release distribution, while Debian’s stable release is point-release (major versions with periodic updates). Void is generally faster and more minimalist, while Debian prioritizes stability and a wider range of supported hardware and software. Debian is generally considered more beginner-friendly.
Void vs. Ubuntu: Ubuntu is a very popular, user-friendly distribution based on Debian. It uses systemd and APT. Ubuntu is known for its ease of use, large community, and wide hardware support. Void is much more minimalist and requires more manual configuration. Ubuntu is a good choice for beginners, while Void is better suited for experienced users.
Void vs. Fedora: Fedora is a community-driven distribution sponsored by Red Hat. It’s known for its focus on free and open-source software and its relatively rapid release cycle (new versions every six months). Fedora uses systemd and the DNF package manager. Void is a rolling release, while Fedora is point-release (although it’s relatively frequent). Void is more minimalist and offers more control, while Fedora is more polished and offers a more “out-of-the-box” experience.
Void vs. Gentoo: Gentoo is a source-based distribution known for its extreme flexibility and customization options. Users compile almost everything from source, allowing for fine-grained control over the system. Gentoo uses the Portage package manager and OpenRC as its default init system (although systemd is an option). Both Void and Gentoo appeal to users who want a high degree of control. Gentoo offers even more control than Void, but it comes at the cost of significantly longer build times and a much steeper learning curve. Void’s xbps-src system provides a good balance between source-based building and the convenience of binary packages.

8. Conclusion: A Distribution for the Discerning User

Void Linux is a powerful, flexible, and rewarding distribution for users who value simplicity, control, and a deep understanding of their operating system. It’s not for everyone, but for those willing to invest the time and effort to learn its intricacies, it offers a unique and compelling experience. Its commitment to independence, its use of runit, its powerful XBPS package manager, and its minimalist base system set it apart from the mainstream.

If you’re an experienced Linux user looking for a change of pace, a developer seeking a clean and efficient platform, or a system administrator looking for a stable and controllable server environment, Void Linux is definitely worth considering. Its growing community and excellent documentation make it a viable option for those willing to embrace its unique philosophy. While it may present a challenge to newcomers, the rewards of mastering Void Linux are substantial: a lean, fast, and highly customized system that truly reflects the user’s preferences.

For UEFI systems:

For legacy BIOS systems:

Leave a Comment Cancel Reply