If you like what we're doing here, please consider becoming a patron.

The Raspberry Pi 400 has been validated as working by the user community.

The Raspberry Pi 3 support is infrequently tested due to lack of hardware.

Please post questions to the Slackware ARM forum.

The support within the proper Linux Kernel is fragile due to the development model of the Raspberry Pi company.

You may need to switch to the RPi Kernel fork for the best experience. You will be offered the option to transition to this Kernel during the integration process, and can also transition from the OS later.

The Installation consists of a number of distinct stages:

1. Acquiring all required hardware
2. Setup of the Raspberry Pi hardware
3. Downloading and Verifying the Slackware assets
4. Writing the Slackware Installer to the Micro SD card
5. Booting the Slackware Installer
6. Installing Slackware
7. Completing the installation
8. Booting the Slackware OS
9. Post installation configuration and tweaks

If you haven’t yet assembled your Raspberry Pi, you may want to review the hardware setup guides. The configuration outlined there was used as the basis for developing this installation guide.

Raspberry Pi 4 Hardware List & Setup Guide

Raspberry Pi 5 Hardware List

You will write the Slackware Installer to a Micro SD card. During the installation process, this SD card will be converted into the system’s /boot partition and will therefore become a permanent part of your setup. However, technically you can move the /boot file system to another type of storage and free up the SD card (with appropriate re-configuration of the RPi's Boot Loader), but this is beyond the scope of this installation guide.

You will need an SD card with a minimum capacity of 16 GB, and it is recommended to use a Class 10 SD card, as these provide the fastest read and write performance available for this type of media.

In this section, we'll prepare the Linux Host Computer to receive and download the Slackware assets required for the installation.

Open a shell on the Linux Host Computer.

We'll download the Slackware Linux distribution into a directory named 'slackware'.

$ cd ## this returns to the root of your home directory
$ mkdir slackware
$ cd slackware

$ pwd
/home/mozes/slackware

The Slackware ARM GPG key will be used to verify your downloads.

$ curl -sSL https://www.slackware.com/infra/keys/arm/GPG-KEY | gpg --import -

For all Raspberry Pi versions:

$ HWM=rpi_generic

At the time of writing, the only version available is 'current'.

$ SLKVER=current

If you are using a mirror server rather than the master Slackware ARM server, set it here. The format is: <hostname>::<rsync module name>

$ SLKSRV=ftp.arm.slackware.com::slackwarearm

$ rsync -PavL $SLKSRV/platform/aarch64/bootware/installer-aio/slackwareaarch64-${SLKVER}/${HWM}.img.xz.asc slkaio.img.xz.asc
$ rsync -PavL $SLKSRV/platform/aarch64/bootware/installer-aio/slackwareaarch64-${SLKVER}/${HWM}.img.xz slkaio.img.xz

The Slackware Installer images are approximately 5 GBytes in size.

Verify the digital signature of the Slackware Installer:

$ gpg --verify slkaio.img.xz.asc

The output will be similar to this. You are looking for 'Good signature from Slackware ARM…'

gpg: assuming signed data in `slkaio.img.xz'
gpg: Signature made Wed 24 Nov 2021 06:07:44 PM BST
gpg:                using RSA key F7ABB8691623FC33
gpg: Good signature from "Slackware ARM (Slackware ARM Linux Project) <mozes@slackware.com>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 36D3 7609 2F12 9B6B 3D59  A517 F7AB B869 1623 FC33

On your Host Computer, obtain root:

$ su -   ## Note the hyphen - it's required

Prior to inserting the Micro SD Card into the USB adapter, we need to see what's already present within the OS so that we can easily locate our Micro SD card:

# lsblk -d
NAME MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda    8:0    0 465.8G  0 disk 

As you can see, this Host Computer there is a single storage device - sda.

Run lsblk again:

# lsblk -d
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda      8:0    0 465.8G  0 disk
sdc      8:32   1    58G  0 disk
sdd      8:48   1     0B  0 disk

As you can see, sdc is 58 GBytes in size. This is the Micro SD card (in this example, it's labeled as '64GB' on the exterior of Micro SD card).

If your Micro SD card has existing partitions, you will not see them surfaced in this list - use lsblk -b to view them.

Enter the directory into which the Slackware assets were downloaded previously:

# cd ~mozes/slackware ## Substitute with the path you noted earlier 
# xzcat slkaio.img.xz | dd status=progress bs=4M iflag=fullblock of=/dev/XXX ## Substitute/dev/XXX with the correct block device
# sync

You may now disconnect the USB adapter/remove the Micro SD card from the Host Computer.

We no longer need to use the Host Computer, so you can logout of the root shell.

# logout

To proceed, you must have:

• Connected the storage to the Raspberry Pi
• Connected the HDMI monitor
• Connected the keyboard (and optionally, mouse)
• Optionally connected the Ethernet cable to set the date via NTP from the Internet
• Inserted the Micro SD card containing the Slackware Installer

If you'd like to encrypt your storage, check the Disk Encryption Guide.

Apply power to the Raspberry Pi and after a few seconds, you will see the “rainbow” screen for several seconds

After that you'll see the Linux Kernel booting:

It takes several seconds to load and boot the installer, and it may take several seconds more for any further output to appear on the HDMI monitor. The process of obtaining an IP address via DHCP can also delay the ability to interact with the Installer.

Once an IP address has been obtained, you will be presented with a prompt. Press ENTER

If you're using a smaller monitor, such as one with a screen size less than 20 inches, it may be necessary to adjust the console font size to ensure that menus and other interface elements fit correctly on the screen. If so, type this into the shell prompt:

setfont ter-v18n

Even if you have a battery pack for the RTC (Real Time Clock), the date on your system may be incorrect. We will sync the date from a highly-available NTP server:

ntpdate clock.akamai.com
hwclock -w

For this installation a basic partitioning scheme will be created.

Partition

Open fdisk against the /dev/sda block device. In this guide, /dev/sda will be your primary storage, and in this guide is the SSD connected to the USB adapter.

fdisk /dev/sda

Clear an existing partition table: Press 'o' to clear the partition table

Create the Swap partition:

Type 'n' for new partition:

Type 'p' for primary partition type:

Press ENTER for the 'First sector'

Type '+4G' for the 'Last Sector'/size:

Change the partition type to 'Swap'. Type 't' then hex code '82':

Create the partition for the root filesystem ('/'):

Type 'n' for new partition. Press ENTER to accept the defaults - this will create partition 2 as the maximum size available.

Type 'a' to mark the root partition (number 2) as bootable Type '2' to select partition 2.

Type 'p' to print to view the partition table.

Type 'w' to write the partition table:

fdisk will now exit.

The Installer will configure the Boot Loader and the OS' /etc/fstab automatically:

Raspberry Pi models prior to the Raspberry Pi 5 do not include an onboard Real Time Clock (RTC). You may have added an external RTC to your system; however, it will not be configured automatically by the Slackware installer and requires additional boot loader configuration.

If your system does not have a working RTC, select Yes at this prompt. If your system does have a correctly configured RTC, select No and complete the required boot loader configuration after installation.

This option simply adjusts entries in /etc/fstab to disable filesystem checks that rely on a valid system clock. You can revert this change at any time by editing /etc/fstab.

Press ENTER to say 'Yes'.

If you would like to install from an alternate media source, pick 'No' and you will be presented with options to install over NFS, USB and HTTP amongst others.

Ordinarily you should always say 'Yes' unless you've been directed to do otherwise.

You can now choose the package sets to install. The recommendation is to install everything. A full Slackware installation will occupy approximately 15GB.

Pick the 'terse' option:

The packages will begin installing:

The Slackware Installer will walk you through the standard Slackware setup. The on-screen instructions will suffice.

It's recommended for the Raspberry Pi that a larger console font is configured for the virtual console.

The recommended font is 'ter-732b.psf'. This is the font used within the Installer.

This author recommends using XFCE as it's light weight versus KDE.

Generally you'll want to reboot into the OS.

However, if you are planning on setting up RAID or need to customise the Operating System Initial RAM Disk, you should select 'Shell'.

The Slackware OS will be found within '/mnt'. You can use the 'os-initrd-mgr' tool (Video tutorial).

Once again, you'll see the Rainbow boot screen for several seconds, followed by the Kernel booting.

The system will take a minute to boot.

You may now login as 'root', using the password you set within the installer.

There are a few post-installation configuration tasks to complete.

If Internet access is available to the Raspberry Pi, prior to proceeding with any further setup, you may wish to set the time now as a one-off event:

Elevate yourself to root and use ntpdate:

$ su - 
# ntpdate rolex.ripe.net  # or pick your favourite NTP server
# hwclock -w # writes the date to the RTC
# logout

Even if your Raspberry Pi has an RTC (as documented in this guide), you may wish to configure it to set time from an Internet NTP Server. The Raspberry Pi requires continuous Internet access for this to function.

You should add a plebeian (non-root) user using the 'adduser' tool.

This is documented here.

If you are using KDE, you need to first adjust a setting.

As your plebian user, prior to loading KDE, run this command.

kwriteconfig5 --file kwinrc --group Compositing --key Enabled false

You may now start KDE.

If you elected to use the Mainline Linux Kernel rather than the vendor fork, you will receive errors such as:

INIT: ID "s0" respawning too fast: disabled for 5 minutes

This is due to the upstream support and cannot yet be resolved (although we're tracking it).

To solve this, you need to comment out the configuration.

As root:

sed -i '/^s0/ s/^/#/'  /etc/inittab
killall -HUP init

When serial support works in mainline, you'll need to revert that change. Keep an eye on the Slackware ARM Linux Questions forum

If you prefer to use a graphical login manager, you can configure the default runlevel as 4:

su - 
sed -i 's?id:3:?id:4:?g' /etc/inittab
reboot

One of the preferred tools to keep your system up to date is slackpkg.

Often Kernel modules for discovered hardware will be automatically loaded, but occasionally you will need to manually configure the loading of some modules.

/etc/rc.d/rc.modules.local

This file is a shell script that is run as one of the last steps before the OS has fully booted. You can enter modprobe commands here to load the specific modules you require.

Configuration files within the directory /lib/modprobe.d/ can be used to configure the parameters of the modules. Existing files within that directory serve as reference examples should you need them.

There are a number of peripherals that may require Kernel modules loading early on in the boot sequence. An example of this would be RTCs (Real Time Clocks) or storage controllers that are required to access the file systems on which the OS lives.

To load Kernel modules during the early boot sequence, read:

/boot/local/README.txt

As root, the easiest way to begin is by renaming the example script:

mv /boot/local/load_kernel_modules.post.sample /boot/local/load_kernel_modules.post

Then add the appropriate module loading commands to: /boot/local/load_kernel_modules.post You can also add shell code here to initialise a peripheral - writing something to the peripheral's Kernel interface, for example.

The Slackware Installer image contains a type ext4 partition labeled SLKins_aio-pkgs from which the packages are installed.

root@slackware:~# mount LABEL=SLKins_aio-pkgs /mnt/zip
root@slackware:~# cat /mnt/zip/README.txt 
This file system contains the Slackware repository that is used during the
installation of Slackware.

Once you've booted into your OS you can delete or change this partition if you
wish, or perhaps you might like to retain it for future reference.

root@slackware:~#

If you'd like to customise the Linux Kernel, the easiest way is to follow the HOWTO guide and use the Slackware ARM Kernel build script to create new packages.

This document also covers using the Raspberry Pi Kernel fork (although this is not recommended).

The Raspberry Pi firmware is managed by the Slackware packages.

The Raspberry Pi boots from a FAT partition on the Micro SD card. This partition contains the closed-source proprietary boot loader, firmware and various other assets it requires. It is mounted within the Slackware OS under /boot/platform/hwm_bw (on other distributions these files reside within /boot).

These assets are provided and managed by the Slackware package a/hwm-bw-raspberrypi.

The Slackware package a/hwm-bw-raspberrypi contains the available firmware that can be programmed to the Raspberry Pi's EEPROM.

You also need to have the a/rpi-userland package installed.

To update the firmware on your RPi's EEPROM; as root:

  $ rpi-eeprom-update -d

This will report if there's newer firmware available.

To update the firmware:

  $ rpi-eeprom-update -d -a

If the firmware was successfully updated, reboot:

  $ reboot

The firmware for the peripherals on the Raspberry Pi Hardware Models is contained within the Slackware a/kernel-firmware package.

The Raspberry Pi's Native Boot Loader configuration file is located at /boot/platform/hwm_bw/config.txt

All of the available parameters are documented on the Raspberry Pi web site.

There are a few notes around the Slackware implementation:

Device Tree Overlays can be configured within the Raspberry Pi's Native Boot Loader configuration file: /boot/platform/hwm_bw/config.txt

The Raspberry Pi 5 includes an onboard Real-Time Clock (RTC) capable of maintaining the system clock. To preserve the time while the device is powered off, an external battery must be connected to the RTC header.

Please note that the RTC battery is optional and must be rechargeable if charging is enabled. Refer to the warning above for important safety information.

If you are certain that a compatible rechargeable battery is connected to your Raspberry Pi 5, you may enable RTC battery charging by modifying the bootloader configuration.

/boot/platform/hwm_bw/slk_config.txt

By default, this setting is commented out within the Raspberry Pi 5 section of the bootloader configuration file. You can uncomment it and reboot.

The Raspberry Pi's are only intended to run the vendor's own Linux distribution, or to run as an 'Appliance' using the Raspberry Pi Linux Kernel fork.

As a consequence, the upstream mainline Linux Kernel in which support for the Raspberry Pi is fragile and prone to breaking without notice. Slackware uses official upstream repositories/releases and has a no-patch policy. As such, the recommendation of using the vendor's own Kernel fork is far outside the scope of Slackware.

Over time the fixes and new features for the Raspberry Pi will continue to appear in the main stream Kernel. However, if you are facing instability or need some specific feature that isn't yet available in the mainline official Linux Kernel, Slackware provides replacement Kernel packages that are built from the Raspberry Pi's Linux Kernel fork.

Slackware comes with a good base of software applications, but there are plenty more available in the Open Source Ecosystem.

The best way to add new software is to use the build scripts from SlackBuilds.org.

This documentation discusses using the Raspberry Pi without the UART/Serial console.

If you'd like to use one, there are two that have been tested.

This image below shows the PL2302 (the Serial adapter listed in the Hardware table at the head of this document) connected to the Raspberry Pi 4:

This is the model shown here.

Once wired up, connect the USB end of the adapter into your Linux Host Computer, and use the following command.

screen  -T screen-256color /dev/ttyUSB0 115200

There are a plethora of ARM devices on the market which requires initial R&D and continuous testing. If you'd like to help Slackware support more ARM boards, please check out the documentation explaining how to get involved.

RPI GPIO exposition

RPi4 GPIO pin layout (credit: Les Pounder)

Adafruit RTC wiring documentation