Configuring
This page serves as a high level overview for configuring a finix system. It intentionally avoids exhaustive coverage of any specified module's configuration options for the sake of brevity, serving more as a quick reference guide. For a full list of configuration options, see the options search.
Note
This page is a stub. If you have something you would like to contribute, feel free to open a PR and add any documentation for configuring services, programs, or low level system components.
General notes
- Most programs and services have an option to enable debug logging, commonly under
programs.*.debugorservices.*.debug. - Most programs and services have an option to change the package providing the main binary, commonly under
programs.*.packageorservices.*.package.
Core system components
Init system and service manager
Finix utilises Finit as its primary init system and service supervisor. Beyond service and one shot task declarations, Finix exposes an extensive amount of customisation options for Finit that can help users fine tune its performance, set environment variables shared among all services, manage kernel cgroups, and much more. These options are derived from upstream configuration and defaults. This section will go over a limited set of these defaults relevant to most use cases. If you're looking for more extensive documentation for all available Finit customisations exposed by Finix, consult the Finit section in the options search.
Runlevels
Finit supports runlevels numbered 1 through 9, with runlevel S representing a bootstrap runlevel. Finix adheres to the runlevel specification outlined by upstream documentation as follows:
S: bootstrap1: single user mode2-5: traditional multi-user mode6: reboot7-9: multi-user mode (extra)0: shutdown
Most services operate in runlevels 234, but services which manage graphical environments reside in runlevels 34. This is the runlevel that all greeter services reside.
The default runlevel started after bootstrap that Finix configures is 2. While this default allows most services to run without modification, greeter services will be prevented from executing even if they are enabled. You can change the default runlevel by adding the following line:
finit.runlevel = 3;
Cgroups and default CPU weight
Finit supports configuring cgroups both globally and on a per-service basis. Explaining the full breadth of all cgroup options is far beyond the scope of this section - consult upstream documentation for a full explanation - but it will go over one notable default set by Finit that may affect system performance for desktop users.
Finit sets the default CPU weight to 9700, which will cause any compilation actions triggered by system rebuilds to deprive any X11 desktop or Wayland compositor and audio stack of most resources, causing severe performance degradation. To set a different weight, you can add the following line to your configuration:
finit.cgroups.cpu.system = {
"cpu.weight" = 100;
};
Hardware options
Finix exposes the hardware.* option set for customizing low level aspects of a finix system, such as:
hardware.firmware: configure firmware packageshardware.console: configuring TTY consoleshardware.cpu: configure CPU microcode packages and enable automatic microcode updateshardware.graphics: configure support for graphics drivers; required for some GUI programs to function, e.g. Steamhardware.i2c: configure support foric2diskshardware.nvidia: configure support for Nvidia graphics drivershardware.uinput: configure support for the kernel'suinputfeature
This option set is imported by default.
Note
Most programs that require hardware.graphics.enable to be true do so automatically when enabling the module.
Bootloaders
limine
Finix currently ships limine as the only available bootloader program. It can be installed on BIOS and UEFI systems, with support for x86-64, aarch64, and riscv64 architectures. It supports both MBR and GPT partitioning schemes, as well as the FAT12/16/32 and ISO9660 filesystems. It may also be configured to support secure boot with sbctl.
This program is not imported by default. To enable it, add the following to your configuration:
{ config, modules, ... }:
{
imports = [ modules.limine ];
programs.limine.enable = true;
}
BIOS support
Limine supports UEFI out of the box, but it can be configured to boot on BIOS systems. To enable limine's BIOS support, add the following to your configuration:
programs.limine.biosSupport = true;
To denote the BIOS device to install to, set the following option:
programs.limine.biosDevice = "/dev/sda";
The specified device must be a whole disk name.
Limiting the number of generations
To limit the maximum amount of generations limine keeps in your boot partition, set the following option:
programs.limine.maxGenerations = 10;
Adding additional entries
To add additional bootable entries to limine, you will need to specify the following items in limine's configuration syntax:
- boot protocol
- location of executable or kernel
- name of entry
Here is an example of adding an entry for the GRUB bootloader located on a separate disk drive.
programs.limine.extraEntries = ''
/+Arch Linux
//GRUB: Arch Linux
protocol: efi
path: uuid(...):/EFI/grub/grubx64.efi
'';
You can obtain the UUID for the desired disk partition with lsblk -f. If the normal UUID does not work, try the disk's PARTUUID obtained from blkid. See upstream documentation for more details.
Configuring secure boot
To enable limine's secure boot support, enable the configuration option.
programs.limine.secureBoot.enable = true;
Enabling this option will still require pre-generated secure boot keys. The limine module has configuration options under the secureBoot option set you can use to automate this process:
autoEnrollKeys.enable: Enrolls automatically generated secure boot keys.autoEnrollKeys.extraArgs: Extra arguments to pass to thesbctlexecutable. Defaults to--microsoftand--firmware-builtinto automatically add secure boot keys signed by Microsoft and builtin device firmware.autoGenerateKeys: Enable generating keys automatically when none exist during bootloader installation.
Wallpapers
Limine supports adding custom wallpapers to be shown in the background of the boot menu. To add a wallpaper, add the following line:
programs.limine.settings.wallpaper = [ pkgs.nixos-artwork.wallpapers.simple-dark-gray-bootloader.gnomeFilePath ];
If more than one wallpaper is listed, a random one will be chosen during boot.
See the section on Limine in the options search for a full list of limine's configuration options.
Custom boot script
Finix exposes boot.loader.script for installing any bootloader not shipped by finix. See the module for efistubmgr in community-modules for a reference implementation.
Filesystems
Finix's filesystem configuration syntax is nearly the same as NixOS. The following filesystems are currently supported:
- 9p
- btrfs
- ext2
- ext4
- f2fs
- fuse
- iso9660
- LUKS
- LVM
- ntfs3
- squashfs
- tmpfs
- vfat
- xfs
- zfs
Support for each filesystem configuration is automatically enabled in both the initial ramdisk and a live system when the fsType option is specified.
ZFS
It is commonly reported that ZFS does not work with the latest release of the kernel. It is recommended to use the latest ZFS compatible LTS kernel with boot.kernelPackages = pkgs.linuxPackages.
Note about encrypted LUKS volumes
Finix does not ship the boot.initrd.luks.devices option set, so you will need to manually add entries for the encrypted volume and its respective mapped name in /dev/mapper. Here is an example configuration:
fileSystems."/" = {
device = "/dev/mapper/crypted";
fsType = "ext4";
};
fileSystems."crypted" = {
device = "/dev/disk/by-uuid/...";
fsType = "luks";
neededForBoot = true;
options = [ "--debug" ];
};
Note
There is a reported issue preventing cryptsetup from opening the declared device if a user has no options attribute. As a workaround, set it to [ "--debug"] to enable debug logging. This will clutter your console output in the initial ram disk but it will allow cryptsetup to open the correct device.
If you have a swap partition encrypted with LUKS, you will need to declare it as a LUKS device and add the appropriate mapping to the list of swapDevices. Here is an example configuration:
fileSystems."crypted-swap" = {
device = "/dev/disk/by-uuid/...";
fsType = "luks";
neededForBoot = true;
options = [ "--debug" ];
};
swapDevices = [
{ device = "/dev/mapper/crypted-swap"; }
];
Device managers
Finix currently ships four userspace device managers, which are programs responsible for handling kernel events as well as populating the /dev directory with input devices, storage devices, rendering devices, and more. None are enabled by default. The following is a list of device managers supported by finix and the level of hardware compatibility a user can expect from each one.
eudev
eudev is a fork of systemd with the aim of isolating the device manager from the rest of systemd. It has the broadest compatibility with any given hardware, given the ubiquity of systemd-udev in the Linux ecosystem. It is capable of reading udev-style device rules and requires no tinkering to reach feature parity with systemd-udev. Any prewritten udev rules installed by Nix packages will work without issue.
This service is imported by default. To enable it, add the following line to your system configuration:
services.udev.enable = true;
Some software packages may ship prewritten udev rules as a runtime dependency. To add these udev rules to /etc/udev/rules.d, add the following line to your configuration:
services.udev.packages = [ pkgs.libtmp.out ];
gardendevd
gardendevd is a device manager designed to be a lightweight replacement to systemd-udev. It is able to read and parse udev-style device rules to populate device nodes. It optionally runs on top of mdevd, another lightweight device manager, but it is runnable as a standalone daemon. Some programs may require recompilation with libudev-garden, a fork of libudev-zero written to be used with gardendevd. Issues have been reported regarding the reliability of services written to be tightly integrated with systemd-udev -- particularly gvfs and udisks2. It is possible that users will need to write custom udev rules to support any uncommon hardware not covered by the stock rules shipped by gardendevd.
This service is imported by default. To enable it, add the following line to your system configuration:
services.gardendevd.enable = true;
Optionally, you may also enable mdevd to run under gardendevd.
Software packages that ship udev rules can be installed and read by gardendevd with the following:
services.udev.packages = [ pkgs.libtmp.out ];
services.udev does not need to be enabled for this option to work.
keventd
keventd is the device manager bundled with finit since version 5 and up. It is capable as a lightweight replacement to systemd-udev in tandem with libudev-zero, as it is able to read udev style rules. It is not as feature complete as gardendevd at the time of writing, and some programs and services will need to be recompiled with libudev-zero in place of libudev in order for them to function properly with keventd. Issues have been reported regarding the reliability of services that are tightly integrated with systemd-udev -- notably gvfs and udisks2, and it is possible that end users will need to write custom udev rules to support any uncommon hardware not covered by the stock rules shipped by keventd.
This service is imported by default. To enable it, add the following line to your system configuration:
services.keventd.enable = true;
Software packages that ship udev rules can be installed and read by keventd with the following:
services.udev.packages = [ pkgs.libtmp.out ];
services.udev does not need to be enabled for this option to apply.
mdevd
mdevd is a lightweight device manager from the Skarnet/s6 family of Linux system utilities. It is designed to be a drop in replacement to the mdev device manager included in the BusyBox software suite. It is by far the leanest of the four device managers, and it has the narrowest hardware compatibility. It is ideal for systems with limited resources or those with little need for broad hardware support beyond standard input and storage devices. Programs and services dealing with low level input, notably pipewire and most graphical environments, will require recompilation with libudev-zero in order to function properly. gvfs and udisks2 will not work with this device manager. If any additional hardware support is desired, a user will need to write custom rules utilising mdevd syntax, which is wholly unique to udev syntax. Examples for what these rules look like may be found here.
This service is imported by default. To enable it, add the following line to your system configuration:
services.mdevd.enable = true;
You may supply additional device rules with the following options:
services.mdevd.coldplugRules = '''';
services.mdevd.hotplugRules = '''';
It is generally advised when running this device manager to set the value of services.mdevd.nlgroups = 4 in order to rebroadcast kernel events to libudev-zero.
getty
getty is a program that manages login terminals. Finit ships with a built-in getty implementation used by default when getty is enabled.
This service is not imported by default. To import and enable it, add the following to your system configuration:
{ config, modules, ... }:
{
imports = [ modules.getty ];
services.getty.enable = true;
}
You may also switch your preferred getty implementation using services.getty.package, like so:
services.getty.package = pkgs.util-linux // { mainProgram = "agetty"; };
Localisation
Finix exposes the i18n.* option set for configuring libc localisation settings. These settings accept locale codes defined by the i18n industry standard for internationalisation. A full list of supported locale codes can be found here. Generally, they are written in the following format:
la_CN.CHARSET
where la is a two letter shorthand language code, CN is a two letter shorthand country code, and CHARSET is a character set.
The default value for i18n.defaultLocale, which determines the default language for system messages, date/time formatting, sort order, etc., is en_US.UTF-8. To change this value, set the following in your configuration:
i18n.defaultLocale = "nl_NL.UTF-8";
Users may further configure system-wide locale settings other than LANG by declaring extra attributes in the i18n.extraLocaleSettings attribute set, as seen in the below example:
i18n.extraLocaleSettings = {
LC_MESSAGES = "en_US.UTF-8";
LC_TIME = "de_DE.UTF-8";
};
A full list of compatible options can be found in section 5 of the locale man page.
Additional locales can be installed by adding the corresponding locale code to the i18n.supportedLocales list, with new lines separating each entry. For example:
i18n.supportedLocales = [
"en_US.UTF-8/UTF-8"
"nl_NL.UTF-8/UTF-8"
"nl_NL/ISO-8859-1"
];
Users may also choose to provide a custom locale codes package with the i18n.glibcLocales option.
Shells
Finix ships configuration modules for three login shells:
ashbashfish
These all live under the programs.* module set. Additionally, you may specify a POSIX-compliant shell package to use for /bin/sh with programs.sh.package.
Any one of these shells listed above may be imported and enabled with the following option:
{ modules, ... }:
{
imports = [
modules.ash
modules.bash
modules.fish
];
programs.<your shell>.enable = true;
}
[!NOTE] Non POSIX-compliant shells (notably
fish), or shells with no backwards compatibility with POSIX syntax, will not be able to source environment variables declared inenvironment.variables. See Setting environment variables for more details.
If a user does not have any shell package specified under user.defaultUserShell, pkgs.bashInteractive will be used as the default login shell for any users created with isNormalUser = true.
Basic network configuration
Configuring hostname, hostId, and /etc/hosts
Configuring network options such as the system hostname, hostId, and /etc/hosts can be done with the following:
networking.hostname = "finixbox";
networking.hostId = "4e98920d";
networking.hosts = {
"127.0.0.1" = [ "foo.bar.baz" ];
"192.168.0.2" = [ "fileserver.local" "nameserver.local" ];
};
ifupdown-ng
Finix provides a module for ifupdown-ng, a network device manager that is largely compatible with Debian's ifupdown, BusyBox's ifupdown, and Cumulus Networks' ifupdown2.
To import and enable this program, add the following to your system configuration:
{ modules, ... }:
{
imports = [
modules.ifupdown-ng
];
programs.ifupdown-ng.enable = true;
}
Configuring
Ifupdown-ng can be configured to manage any network interface on your machine. It can assign static IP addresses, specify default gateways, specify network interface dependency chains, and declare any desired executors. Finix exposes the following options to handle these use cases, all under the programs.ifupdown-ng.* attribute set:
auto- Designate interfaces to be automatically configured by the system.extraArgs- Extra command line arguments to pass to ifupdown-ng -- see ifupdown-ng(8) for details.iface.<name>.address- Specify the ipv4 or ipv6 address thatiface.<name>should use.iface.<name>.gateway- Configure the gateway address thatiface.<name>should use.iface.<name>.requires- Specify any network interfaces that must be brought up beforeiface.<name>.iface.<name>.use- Specifies which executor to use.
Any network interface configured under iface will be automatically brought up by a Finit one-shot task on a system rebuild. An example interface configuration may consist of the following:
programs.ifupdown-ng.iface = {
eth0 = {
address = [ "203.0.113.2/24" "2001:db8::2/64" ];
gateway = "203.0.113.1";
use = "dhcp";
};
};
[!CAUTION] Switching device managers will cause the default names for your network interfaces to change, potentially breaking your configuration.
Finix also exposes settings.* to allow for custom configuration outside of these predefined options. Any configuration defined in nix will automatically be transpiled to ifupdown-ng's native configuration format. See upstream documentation for more details.
Network daemons
Finix offers three automatic network device managers:
NetworkManager is confirmed to work with eudev and gardendevd. If you are using seatd instead of elogind, your user will need to be a part of the networkmanager group in order to configure network interfaces as a normal user. Iwd and dhcpcd are both device manager agnostic and do not require any specific session manager to function.
To import and enable any of these services, add the following to your configuration:
{ modules, ... }:
{
imports = [
modules.networkmanager
modules.iwd
modules.dhcpcd
];
services.<network daemon>.enable = true;
}
NetworkManager and dhcpcd will conflict if both are enabled at the same time. However, iwd and dhcpcd may be enabled at the same time with zero negative side effects.
Configuring NetworkManager
NetworkManager configuration settings may be added with the settings attribute. See upstream documentation for details.
Configuring iwd
Iwd configuration settings may be added by with the settings attribute. See upstream documentation for details.
[!CAUTION] Iwd has not been updated in some time, and it has unpatched CVEs in its most recent release at the time of writing. It is recommended to choose an alternative wireless manager if you are configuring finix on security critical machines.
Configuring dhcpcd
Dhcpcd can be configured with the following options:
debug- Enable debug logging.extraArgs- Additional arguments to pass to dhcpcd.settings.*- Dhcpcd configuration settings. Consult the section on dhcpcd in the options search in the options search for more details.
System time
Configure timezone
To configure the system time zone, set the time.timeZone option to any valid time zone code specified in the standard tz database, like so:
time.timeZone = "America/Chicago";
See the following resource for a list of valid time zone codes: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
NTP
Finix ships a configuration module for chrony, a network time protocol daemon. This service is not enabled by default. To enable it, add the following to your configuration:
{ config, pkgs, modules, ... }:
{
imports = [
modules.chrony
];
services.chrony.enable = true;
}
Additional configuration can be delcared for chrony under the services.chrony.* attribute set. The following options are exposed:
package: the package to use for chronyconfigFile: a custom configuration file sourced via absolute path; see upstream documentation for detailsdebug: whether to enable debug logging
Nix daemon
TODO
Network security
Firewalls
[!CAUTION] Finix does not enable any firewall service by default -- it is highly recommended to enable one.
nftables
Currently, finix only ships the nftables firewall implementation.
To import and enable nftables, add the following to your configuration:
{ modules, ... }:
{
imports = [ modules.nftables ];
services.nftables.enable = true;
}
The default filter table operates on a default deny policy for incoming connections on all ports initiated by external IP addresses. Incoming and outgoing traffic on connections established by local network interfaces are unaffected.
Nftables can be configured with the following options:
rejectPackets- Whether refused packets are rejected rather than dropped.trustedInterfaces- Network interfaces to trust unconditionally. All network traffic is accepted on specified interfaces regardless of any ports opened throughproviders.firewall.
Users may also configure custom rule tables with nftables syntax by adding to the tables attribute. See the section on nftables in the options search of the options search for more details.
providers.firewall
providers.firewall is a generic abstraction for firewall implementations shipped by finix that allows module authors (or end users) to open ports on any firewall service without having to directly interface with any of them. If a firewall backend is enabled, rules specified under providers.firewall are enabled. Otherwise, they are ignored.
If a user is unfamiliar with a firewall's specific configuration syntax, the firewall provider serves as a user friendly interface to quickly open TCP and UDP ports. Users can specify a list or range of ports to open with the following options:
allowedTCPPortsallowedTCPPortRangesallowedUDPPortsallowedUDPPortRanges
While allowedTCPPorts and allowedUDPPorts simply take a list of port numbers, ranges take a list of attribute sets containing the from and to options for inclusively specifying a range of port numbers to open, like so:
providers.firewall.allowedUDPPortRanges = [
{
from = 60000;
to = 61000;
}
];
The firewall provider does not allow specifying a list of trusted network interfaces - these need to be configured under each firewall service.
VPNs
TODO
IP blocklists
sshguard
TODO
DNS
TODO
ssh
- dropbear
- openssh
TODO
User management
This section contains information for general user management.
Session managers
TODO
sessiond, seatd, elogind
Setting environment variables
Using security.pam.environment
The security.pam.environment option uses pam's pam_env module to set environment variables, which are then available to:
- Interactive and non-interactive shell sessions
- Privilege escalation/background job runners like
sudoandcron - GUI authenticators like polkit-kde-agent-1
- Display managers like ly, LightDM, and gdm
- etc.
{
security.pam.environment = {
"FOO".default = "bar";
EDITOR = {
default = "nvim";
override = "nvim";
};
};
}
Each line starts with the variable name, there are then two possible options for each variable DEFAULT and OVERRIDE. DEFAULT allows an administrator to set the value of the variable to some default value, if none is supplied then the empty string is assumed. The OVERRIDE option tells pam_env that it should enter in its value (overriding the default value) if there is one to use. When OVERRIDE is not used, "" is assumed and no override will be done.
- Extract from PAM_ENV.CONF(5)
This option is ideal for setting variables for your graphical environment and non-CLI programs, as they are not typically executed via an interactive login shell and won't get the variables from environment.variables. It also does not require a POSIX compliant login shell to function.
Using environment.variables
Variables defined here are set via POSIX syntax shell scripts created by the shells module, which are sourced by login shells like bash and ash.
[!NOTE] Some shells do not source these scripts, which means variables configured through this method will not be set in:
- Non POSIX-compliant shells, like
fish.- Shells that are configured without/don't have a provided Finix module yet, like
zsh.
{
environment.variables = {
FOO = "bar";
EDITOR = "nvim";
};
}
This method is ideal for setting variables used by CLI programs and anything executed from the terminal, but security.pam.environment is still usable for this purpose.
Graphical environments
This section contains information for setting up and using graphical environments.
Fonts
TODO
Login managers
- greetd
- regreet
- ly
- lemurs
TODO
Wayland compositors
TODO
labwcnirihyprlandsway
etc.
Xorg
TODO
vxwmopenbox
etc.
Desktop environments
TODO
lxqtcosmic-de
etc.
Audio
PipeWire
[!NOTE] Enabling the PipeWire and WirePlumber modules does not configure them to be started as
finitservices. See Running PipeWire, WirePlumber andpipewire-pulse.
Finix provides a PipeWire module which is not imported by default. To enable it, add the following to your configuration:
{ config, modules, ... }:
{
imports = [ modules.pipewire ];
programs.pipewire.enable = true;
}
The module has a settings option to configure PipeWire.
The following example provides a PipeWire and JACK configuration that may help reduce audio crackling and popping on some systems under high CPU load.
{ config, modules, ... }:
{
imports = [ modules.pipewire ];
programs.pipewire = {
settings = {
"10-low-latency" = {
"context.properties" = {
"default.clock.rate" = 48000;
"default.clock.quantum" = 800;
"default.clock.min-quantum" = 512;
"default.clock.max-quantum" = 1024;
};
};
};
jack.settings = {
"12-jack-low-latency" = {
"jack.properties" = {
"node.latency" = "512/48000";
};
};
};
};
}
Source: EndeavourOS Forum: Pipewire Guide audio crackling/popping and latency, Official PipeWire configuration documentation
Using WirePlumber is also advised for session management.
WirePlumber
Finix provides a WirePlumber module which is not imported by default. To enable it, add the following to your configuration:
{ config, modules, ... }:
{
imports = [
modules.pipewire
modules.wireplumber
];
programs = {
pipewire.enable = true;
wireplumber.enable = true;
};
}
ALSA, JACK and PulseAudio compatibility
Some programs may not function properly without ALSA, PulseAudio and JACK. The PipeWire package provides options to enable full compatibility for these audio stacks. To enable ALSA and JACK compatibility, add the following to your configuration:
{ config, modules, ... }:
{
imports = [ modules.pipewire ];
programs.pipewire = {
enable = true;
alsa.enable = true;
jack.enable = true;
};
}
To enable PulseAudio compatibility, pipewire-pulse must be executed after pipewire. See Running PipeWire, WirePlumber and pipewire-pulse.
Running PipeWire, WirePlumber and pipewire-pulse
Because finit does not yet support user level services, starting pipewire, wireplumber and pipewire-pulse must be done via your graphical environment or PipeWire's configuration.
As an example, here is how to start all three in Niri:
spawn-sh-at-startup "pipewire & sleep 1 && pipewire-pulse & wireplumber"
[!TIP] A
sleepcall is added after executingpipewireto avoid a race condition wherepipewireisn't initialized in time forwireplumberandpipewire-pulseto hook into it. It is preferable to execute both via PipeWire's configuration to avoid this hack.
[!CAUTION] Running PipeWire as root is highly discouraged due to significant security risks.
Here is how to accomplish the same using PipeWire's configuration:
{ config, modules, ... }:
{
imports = [
modules.pipewire
modules.wireplumber
];
programs = {
pipewire = {
enable = true;
settings = {
"context.exec" = [
{
path = lib.getExe' config.programs.wireplumber.package "wireplumber";
}
{
path = lib.getExe' config.programs.pipewire.package "pipewire-pulse";
}
];
};
};
wireplumber.enable = true;
};
}
ALSA-only
[!WARNING] PipeWire is more widely supported and easier to setup. This setup is only advisable if you need a super minimal audio stack, like on older hardware or low power SOCs.
To create a basic ALSA configuration, add the following to your configuration:
{
environment.etc."asound.conf".text = ''
ctl.!default {
type hw
card "Generic_1" # Replace Generic_1 with your card name from `aplay -l`
}
pcm.dmixer {
type dmix
ipc_key 1024
ipc_perm 0666
slave {
pcm "hw:Generic_1,0" # Replace Generic_1 with your card name from `aplay -l`
period_size 1024 # Prevent audio cracking on certain cards
buffer_size 4096
}
}
pcm.!default {
type plug
slave.pcm "dmixer"
}
'';
}
See upstream documentation for more details.
Server software
Databases
TODO
postgresql, mariadb
Containerization
TODO
- docker (no rootless support)
- incus
Virtualization
- waydroid
- incus
Schedulers
TODO
providers.scheduler
Miscellaneous
Bluetooth
TODO
Specialisations
TODO
Alternative libc
TODO