Learn Void Linux - Rolling Release & Nonfree Repo

#Introduction

Episode 17 touches the heart of Void's identity: the rolling release model. There are no release versions — the system is always moving toward the latest package versions. You'll understand how this model works, how Void maintains its stability, and how tools like void-updates help you time your upgrades.

We'll also cover the nonfree repository, the gateway to drivers and proprietary packages. Understanding when to enable it and how it works will save you from surprises down the road.

Let's dissect Void's rolling release model.

#The Rolling Release Model

#The Continuous Update Concept

In a rolling model, there's no big version upgrade. Each package is updated to its latest version when ready, and the system is always at the newest combination of packages. The benefit: new features and security fixes come continuously, without waiting for the next release.

Check how fresh your system is:

ls -lt /var/db/xbps/pkgdb-0.38.plist | head -n 2

#Stability Policy

#Testing Before Release

Rolling releases are often criticized as unstable, but Void handles this with testing. New packages don't land directly in the current repository. They go through maintainer review, dependency testing, and evaluation of their impact on other packages.

This means there's a gap between an upstream release and its availability in the repository — a fair price for stability. You can feel this policy in the calmer rhythm of updates.

#Timing Your Updates

For production systems, don't upgrade the second a package becomes available. Monitor announcements of big changes and schedule upgrades when there's no important traffic:

xbps-install -S -n

The -n option on xbps-install shows what would be upgraded without actually doing it. This is a safe way to assess before acting.

#void-updates: Waiting for Stable Updates

#Installation and Usage

void-updates is a tool that helps you wait for updates through a testing period:

sudo xbps-install -S void-updates
sudo void-updates

The void-updates command shows the differences between the stable repository and the testing repository. This lets you see which updates are being "ripened" before release.

#A Personal Policy

Combine void-updates with a personal schedule:

Daily   : xbps-install -Su (desktop / lab)
Weekly  : void-updates then upgrade important packages
Special : big upgrades scheduled during a maintenance window

Choose a rhythm that matches your risk tolerance.

#The Nonfree Repository

#Adding the Nonfree Repository

The nonfree repository contains packages with non-free licenses, such as NVIDIA drivers. Add it via a configuration file:

repository=https://repo-default.voidlinux.org/current/nonfree

After adding the file, sync the repositories:

sudo xbps-install -S

#Using Nonfree Packages

The most common examples are NVIDIA drivers and certain firmware:

sudo xbps-install -S nvidia
xbps-query -Rs nonfree | head

The xbps-query -Rs nonfree command searches for packages containing the word nonfree in their name or description.

#Mirrors and Synchronization

#Choosing a Mirror

Void provides many mirrors around the world. Change the mirror by overriding the default configuration in /etc/xbps.d/:

repository=https://fastly.voidlinux.org/current

#Verifying Synchronization

After changing the mirror, sync and verify the index time:

sudo xbps-install -S
ls -l /var/db/xbps/repo-*.{plist,xbps} 2>/dev/null

#Conclusion

Episode 17 explained Void's rolling release model: continuous updates balanced by maintainer testing policy, using void-updates to wait for stable updates, adding the nonfree repository, and choosing the right mirror.

Key takeaways:

• Void is always moving toward the latest package versions.
• Packages are tested before entering the current repository.
• xbps-install -S -n shows updates without applying them.
• void-updates helps you wait for stable updates.
• The nonfree repository is added via /etc/xbps.d/99-nonfree.conf.
• Change mirrors by overriding the configuration in /etc/xbps.d/.

In the next episode, episode 18, we will cover containers and cross-arch — running Docker and Podman as runit services, rootless configuration, and understanding Void's aarch64 and armv7l architecture support for Raspberry Pi and cross bootstrapping.