SLACKWARE DESKTOP GUIDE

What Is It..?

If you are familiar with Linux you have probably heard of Slackware. It's the oldest surviving Linux distribution, and over the years it has earned a reputation as an ultra conservative stable and crude simple system. In this article we will take a closer look at how to use Slackware 14.2. We will not cover the generic aspects of using a Linux desktop, since that is covered all over the place on the web, instead we will focus on basic system administration, and package management in particular, which may be different in Slackware to what you are used to.

PS: This is a long and tedious article, if you want the quick version just read the Installation and Desktop section and the Source Code Management - Automatically section under Package Management. Have Fun!

Slackware? Sounds Difficult!

Well, yes and no. Take this 2 second test to see if you have what it takes to become a Slacker: To enable sudo access uncomment the %wheel line in /etc/sudoers. Do you understand what that means? Would you be able to do it? If so you have what it takes, if not you may be in for a rough ride...

Despite it's reputation installing Slackware and firing up a desktop is done in a matter of minutes. The difficulty lies more in post-install configurations and package management. It's design philosophy includes making as few alterations to upstream packages as possible and getting out of your face. Many user friendly Linux distributions include layers of patches and custom configurations, in a valiant attempt to hide the fact that Linux is inconsistent, ugly and difficult. However popular this approach is it has some drawbacks.

For one this user friendliness is only at the surface. Like throwing a blanket over a pile of garbage it doesn't actually solve the underlying problem. When things break the sysadmin needs to understand the underlying system, and in such a crisis simplicity is hard to beat! Since every major distro has their own custom spin on the situation, learning one distro will not necessarily help you on another. Lastly since many distros patch upstream applications liberally it can be hard to debug problems. Does the bug originate from upstream, from the distro patch or is it some local customization that are screwing things up? The fun really begins when a forum gives one suggestion, the distro documents another, and the upstream developers agree with neither...

So even if Slackware lacks makeup and it's philosophy can feel a bit like LFS at times, once you fix a problem it tends to remain solved. Slackware is remarkably consistent and stable. Even better, the problems you encounter in Slackware will be Linux problems, and the tools you use to solve them are Linux tools. So once you have become comfortable with the warts and smells in's and out's of this old distribution, you are not just a Slackware user but a Linux expert. Why even BSD will not throw you any surprises! Just like LFS, Slackware provides a fascinating learning experience, but unlike LFS you start with a fully functional desktop and server at the onset.

Getting Help

Because Slackware avoids making custom changes to upstream software you often don't need distro specific documentation. Are you having trouble with Firefox? Go to the Firefox website. Are you having trouble with vlc? Go to the VLC website. Are you having issues with LibreOffice? Go to the LibreOffice website. The point is: If you are having trouble with a program in Slackware, talk to the developers of that program. The version shipped with this distro is delivered as the authors intended.

A pro tip when googling a Slackware problem: search for "Linux my problem..." or even "BSD my problem...", not "Slackware my problem...", since Slackware users are few but the solution to problems are often similar across distros. As a side note, searching for BSD solutions is often useful since you filter out all the newb, troll and plain erroneous information from the Ubuntu camp...

The semi official Slackware forum is LinuxQuestions.org, many of the Slackware developers hang out there and will answer your questions to the best of their ability. An excellent Linux resource is the Arch Linux Wiki. Of course the information here is specific to that distro, but many of the pointers here will be relevant on other distros as well. You can also subscribe to the Slackware mailing lists to follow it's development and receive support. But don't bother the developers with idle questions, other distro's exist for that purpose.

Yet another channel for support is IRC (Yes the Linux folks still use IRC!). On libera, you can usually find a channel that's specific to your problem. For instance if you were having trouble with the above programs you could go to: #firefox, #videolan, or #libreoffice. Other channels of interest are #linux and ##slackware. If you are unfamiliar with IRC, go to the Hexchat website. IRC is an informal, noisy and rude place. But you can sometimes get a quick answer to a quick question, for a more involved and structured support use the forums or mailing lists.

As a last resort you could pull up your sleeves and get a book. Scary I know, but its the only way to really learn! Two free, albeit dated books, are The Slackware book, and The RUTE book. The FreeBSD Handbook has excellent information too, some of which is even relevant to Slackware. There are also a number of commercial books for Linux. A good starting point would be the Linux Bible from Wiley. O'Reilly has also a huge range of books on any number of Linux topics. You can buy these books at Amazon and other places.

Installation and Desktop

I am not going to walk you through every single detail of the Slackware installation, just read the text carefully and go with the defaults unless you have a good reason not to. But I will give you a few hints: You need to partition your hard drive before you run the setup installer program, I recommend using cfdisk to do this (or you can partition your hard disk from another operating systems first). If you do not understand what "partition" means, do yourself a favor and choose a different Linux distribution. During the network configuration stage of the installer, choose Network Manager. When asked witch desktop to use I recommend KDE if you have the horsepower, Xfce if you don't.

Booting into your new system will disappoint you, it's all text! Don't Panic! Just run startx and you will be greeted by a friendly desktop. Clicking around should get you internet access. You will find all kinds of useful, and not so useful, applications in the menu. However, the only user on this system seems to be root. And lot's of nifty programs, such as LibreOffice, VLC, Steam and whatnot, are missing, but there's no package manager! What gives!?!

It's time for some configurations. And lets be honest, this is where Slackware becomes challenging. But with a little bit of knowhow you should do fine.

PS: It should be noted that you already have a very complete and capable operating system at this point! Probably because Slackware do not have an official software repository, the default installation is specifically designed to be as complete as possible. Complete however is a relative term. Some might feel that a Linux box without Lynx is incomplete, some that a desktop without Chrome is missing something, the Slackware developers belong to the first group of people.

Initial Configurations

User Management

KDE has graphical tools for managing users and groups, but we will walk you through the command line approach. Add a regular user to your system with the adduser command. If you want to add sudo privileges to your user, give the wheel group sudo access by editing /etc/sudoers (eg. nano /etc/sudoers) and uncomment the %wheel ALL=(ALL) ALL line, finally add your user to the wheel group. You can do so by running the command usermod -a -G wheel user, or by editing /etc/group manually.

Keyboard Layout

During installation you were asked to set up your keyboard layout. However, this only applies to the console (the text-based interface), if you start a graphical interface (aka "desktop") it uses the default us layout. The keyboard layout for X needs to be configured separately, to add a french keyboard layout for instance you need to write an X config file, (eg nano /etc/X11/xorg.conf.d/00-keyboard.conf) with the following content:

Section "InputClass"
Identifier "system-keyboard"
Option "XkbLayout" "fr"
EndSection
		

Shell Settings

You may also have noticed that while the shell in your text based environment is quite nice, it highlights directories and links with different colors, it prints a humorous welcome message and has a decent prompt, but when you open up a terminal in your graphical desktop it has none of these things... why?

The systems default shell settings is in /etc/profile, and this file is read when you log in to a text based environment. A graphical terminal however does not read this file, instead it reads $HOME/.bashrc.

The solution? Simple: Add source /etc/profile to your $HOME/.bashrc. But why do you need separate configurations for the graphical interface and the text-based interface?!? This is one of those ugly Linux (actually UNIX) inconsistencies that Slackware makes no effort to hide. It may be annoying at first when you encounter such difficulties, but trust me, you will be glad later when a colleague messes around in his bashrc on the companies Ubuntu server and nothing happens after he reloads his ssh connection... Poor sod didn't realize that he should have put those instructions in ~/.profile. Make no mistake, Ubuntu smells too, it's just layered so thick with perfume that people don't notice.

Booting and Services

By default the boot loader waits patiently for 2 minutes before booting the default choice. This is a bit excessive and you may want to reduce the timeout in /etc/lilo.conf. If you are only running Slackware on this system its probably better to simply comment out the prompt line, this will make the boot loader run the default directly. Finally you can uncomment the compact option witch will speed up boot time. When you are done run the lilo command (as root) to install the new boot loader.

The init system in Slackware is blissfully simple. All the available services are just shell scripts located in /etc/rc.d, the files that have executable permission will be run at startup, those that don't wont. So enable a service by chmod +x /etc/rc.d/rc.some_service and disable by chmod -x. This takes effect after a reboot. If you need to start/stop/restart a daemon without rebooting run the corresponding script with that argument, eg. /etc/rc.d/rc.some_service stop. Lastly if you need to add custom commands to your startup, then add them to /etc/rc.local (fun fact: this last step is not Slackware specific).

As you can see Slackware boots into a textual interface by default. You can manually start a graphical interface with the startx command. The desktop used is the default you choose during installation, you can change this later with xwmconfig. Probably you want to boot into a graphical interface by default, you can do that by editing /etc/inittab and changing the line id:3:initdefault: to id:4:initdefault:

Package Management

Rumors would have you believe that Slackware doesn't have a package manager. It does, it just hasn't got a graphical package manager, or dependency resolution, or a repo... See the distinction? Don't worry though, unofficially it has all of those. But lets be specific.

PS:If you want the quick version, just go here

Binary Package Management - Manually

A Slackware package (usually a .txz file) is actually just a tar archive witch unpacks its contents into the root filetree. It also includes a text file with meta info and optionally a script file executed after installation. You can manually manage these files with commands such as installpkg, removepkg, upgradepkg which are fairly self explanatory. Meta information for these packages are plain text files located in /var/log/packages. If the package also includes a post-install script, it is stored in /var/log/scripts, and can be rerun later at will if needed. These tools do not do dependency checking, so in the grand tradition of UNIX they allow you to shoot yourself squarely in the foot. The upshot is that there is no dependency issues. There are application issues when stuff breaks of course, but that's entirely different...

No doubt the concept of no dependency resolution will seem bat crazy, but this actually works quite well in Slackware. For instance LibreOffice, Skype and Wine can be installed directly in Slackware with no extra dependencies. Contrast this to other Linux distros! There are a number of reasons why dependency management is so simple in Slackware. First of all the base install is fairly large (~8Gb) and it tries to include all the basic libraries and tools you will likely need in order to compile extra software. Secondly Slackware tries very hard to be as patch-free and vanilla as possible, this greatly reduces the need for customized patches and non-standard dependencies. Also many distributions with dependency resolution will often throw in every optional add on for good measure even though its not actually required.

In theory you can freely download 3rd party Slackware binaries and manage them much like a Windows system with the tools described above. In practice though such 3rd party packages are rare (two exception are wine and vlc), and its not exactly a good idea to install random binaries from the web willy nilly (there is a reason why Windows is so insecure).

By the way, the installation DVD contains some useful extra packages that are not installed by default either for licensing issues or other considerations (You can also get these files from one of the many Slackware mirrors). To install Google Chrome and Oracle Java form the DVD for instance, do the following:

# mount /dev/sr0 /mnt/dvd
# mkdir /usr/src/dvd
# cp -r /mnt/dvd/* /usr/src/dvd
		

Grab Chrome and Java from Google and Oracle's web sites and place them in /usr/src/dvd/extra/google-chrome and /usr/src/dvd/extra/java, and then we can make some Slackware packages and install them:

# cd /usr/src/dvd/extra/google-chrome
# ./google-chrome.SlackBuild
# installpkg /tmp/google-chrome-*.txz
# cd /usr/src/dvd/extra/java
# ./java.SlackBuild jdk-*.tar.gz
# installpkg /tmp/jdk-*.txz
		

There is also a rpm2txz command for converting rpm packages to Slackware packages. But don't expect this to magically make any rpm work on Slackware. You need to have the correct set of dependencies (and often the correct version of these dependencies), for this to work, in practice this is only useful for simple applications.

Yet another alternative that's all the rave nowadays is flatpak, and docker, which is available for Slackware on slackbuilds.org.

Binary Package Management - Automatically

The official "repo" of Slackware is the installation DVD. You can manage packages from the official release over the network with the slackpkg command. This is useful for installing security updates, upgrading to a new release and for adding software to a minimal installation. First edit /etc/slackpkg/mirrors and uncomment a mirror near you. You can then issue commands such as slackpkg install/remove/search/info package and so on. For instance, if you somehow managed to completely break Firefox, you can reinstall it like so:

# slackpkg reinstall firefox
		

If you want to update your system you can do it like this:

# slackpkg update
# slackpkg install-new
# slackpkg upgrade-all
# slackpkg clean-system
		

If you find this cumbersome like I do, you can write a little script in /root/bin/upgrade with the following content:

#!/bin/sh
for action in update install-new upgrade-all clean-system; do
	slackpkg -dialog=off -batch=on -default_answer=y $action
done
		

After you have made this script executable (ei. chmod +x /root/bin/upgrade), you can simply upgrade your system with this new command (note that this does not apply to 3rd party addons from SlackBuilds.org).

You can also use slackpkg to upgrade to a new Slackware release by first updating /etc/slackpkg/mirror to point to the new release repo, and then run the above command.

PS: Note however that upgrading from one Slackware release to the next is rarely just a question of upgrading a set of packages. Often you need to run a few manual commands to clean things up as well. The details are described in the UPGRADE.TXT file in the root of the install media. You can either read this from the DVD/iso file or online (eg. http://ftp.slackware.com/pub/slackware/slackware64-14.2/UPGRADE.TXT for instructions on upgrading from version 14.1 to 14.2).

There is also a 3rd party extension to slackpkg appropriately named slackpkg+, this extension will allow you to add 3rd party binary repositories. There aren't many such repos, and you should be careful not to mix in to much stuff since this can cause dependency problems. Some useful addons though are Alien Bobs repo, witch includes many of the usual suspect that are missing from the standard installation (LibreOffice, VLC, ect...). The multilib repo, also from Alien Bob, witch will allow you to run 32-bit programs (such as wine and skype) on a 64-bit installation. Finally slackpkg+ will allow you to easily add your own custom repo, witch is very useful if you have many custom packages or if you need to manage multiple Slackware installations.

So for instance after downloading the sbopkg+ binary you can for instance:

$ su -
# installpkg slackpkg+-1.7.0-noarch-5mt.txz
# nano /etc/slackpkg/slackpkgplus.conf
		

Enable the alienbob and restricted repositories, and add restricted to PKGS_PRIORITY. Once its configured to your likeing, update slackpkg and use the new repos:

# slackpkg update gpg # you only need to run this once after adding a repo
# slackpkg update
# slackpkg install vlc libreoffice-6
		

You can also create templates of installed packages with slackpkg and then automatically install these on other Slackware machines (provided they to have the necessary repositories enabled). Suppose you had just installed the above packages on a machine, and you wanted to install the exact same packages on another Slackware machine, you could do this like so:

# slackpkg generate-template myprogs
# scp /etc/slackpkg/template/myprogs.template myothermachine.com:/etc/slackpkg/template
# ssh myothermachine.com
# slackpkg install-template myprogs
		

PS: slackpkg does not do dependency resolution, you need to sort that out yourself! So be sure to check a package dependencies with slackpkg info package-name and look for a REQUIRED line (if there is no such line the package doesn't have dependencies).

PPS: slackpkg will only list dependencies not included in the default installation. So if you have a minimal installation without X and so on, you are on your own! The moral: don't exclude packages during installation unless you know what you are doing.

If you want to add the multilib repo and enable Slackware to run 32-bit software on a 64-bit system, you should first read the instructions here.

Finally, it is possible edit /etc/slackpkg/mirrors and enable a current repo. You can then do the upgrade routine to always run the development version of Slackware. Essentially turning it into a rolling release. But beware! You need to stay on top of things if you do this. Subscribe to the mailing lists and familiarize yourself with the forums. Also note that the SlackBuilds.org repository is built for stable releases of Slackware, so you might need to do a bit of jerry rigging to make them work with current.

Source Code Management - Manually

Every so often you may find that you want to install a weird application that is not included in the repo, this is especially true for Slackware. In such cases you may need to compile the software manually. This usually involved the following steps:

  1. Download a package.tar.gz or similar file from the applications web site
  2. Extract the package with tar -xzf package.tar.gz or a similar command
  3. Read any README or INSTALL files in the extracted directory and follow instructions

These will usually be something like:

$ ./configure
$ make
$ sudo make install
		

You will probably note the number of conditionals in the above instructions, usually, or similar, something like... This is because there are a vast number of ways to make and install software on Linux. The quality of the program in question and the install instructions that are provided vary greatly. Additionally sorting out dependency issues by hand and ironing out edge case compatibility problems, is tedious to say the least. The main purpose of a package manager is to take care of all this mess, and lull the casual user into a false sense of security.

In spite of the pain however knowing how to compile software is a useful skill set to have. This process is not easy in any distro, but it is significantly easier in Slackware then most. For one, distros with large binary repositories, such as Debian, will usually split a package into a default version for users and a -dev version for developers. So if you want to compile something that depends on ncurses for instance, having ncurses-base in Debian is not enough. You need to install the libcunit1-ncurses-dev package, and probably a few others as well. Needless to say this naming convention is entirely different in Redhat, and God forbid that you need to adjust one of these packages a with non-standard compile option!

In Slackware the packages are straight from upstream, including everything you need for compilation. Whereas the Debian repo has some 30 plus ncurses packages, Slackware only has one. It is remarkably easy to create custom Slackware binaries or adjust existing ones. Lets illustrate how with a couple of examples:

Compile a Package

Suppose you want to install the experimental and rather weird neercs terminal muliplexer from caca labs, you could to the following:

$ cd $HOME/Downloads
$ git clone git://git.zoy.org/neercs.git
$ cd neercs
$ less README
$ ./bootstrap
$ enable_doc=no ./configure
$ make
$ mkdir -p /tmp/neercs
# create a Slackware package
$ make install DESTDIR=/tmp/neercs
$ cd /tmp/neercs
$ /sbin/makepkg -l y -c n /tmp/neercs.tgz
		

If you drop the last three commands above, and run sudo make install instead, the program will be compiled and installed in the normal way. But by doing the last three steps here, you instead create a Slackware binary package in /tmp/neercs.tgz. As root you can now:

The advantage of installing neercs as a package is that the Slackware package manager is now aware of it. It is easy to remove or upgrade it, and it is very easy to share this package with other machines.

Slackware already included all the necessary dependencies, but I had some LaTeX issues when I tried to compile this particular package, so I changed one of the compile options to enable_doc=no. Exactly what compile options are available will depend on the software in question. The important thing to note here is: make install DESTDIR=/tmp/neercs, the DESTDIR variable makes the installer put the files in this directory rather then spraying them all over your root file system. This is vital, because it allows us to run the makepkg command on this directory and thus create a binary containing these files.

PS: Not all source packages have a DESTDIR option in their Makefiles, check with grep DESTDIR Makefile. Some source code use PREFIX, prefix or INSTALL_ROOT instead, while others do not have this functionality at all. In that case you might be able to use ./configure --prefix=/tmp/package or you may have to manually move the files into the correct location after installation. Did I mention that compiling stuff can be a real pain?

Recompiling a Package

The above example is a quick and dirty way to make a Slackware binary, the official binaries are generated by a shell script that basically follows these steps, but needs to take care of some further details such as figuring out what architecture you are running and which version you are building. It also has a few conventions, all packages are built in /tmp/package-name and the resulting binaries are placed in /tmp, and so on. If you want to submit a SlackBuild to slackbuilds.org, or if you want to make adjustments to packages that come with Slackware you should familiarize yourself with these instructions.

Now suppose you need to adjust an application in Slackware. For instance the cacaview image viewer that comes with Slackware has been compiled with the --disable-imlib2 option. This makes sense since Slackware does not include imlib2 by default. I however always install this library since its a dependency for some programs I need, also without imlib2 support cacaview is not able to open popular image formats such as png and jpeg. Well how do I change this application?

First we need to find out which package cacaview was installed with. A quick grep cacaview /var/log/packages/* reveals that it was installed with the libcaca package. You can either get the source code for this package on the DVD under source/l/libcaca or online (eg. mirrors.slackware.com/slackware/slackware64-14.2/source/l/libcaca), and put the files in $HOME/pkg/mysbo/libcaca. Now to customize and install the application:

$ su -
# cd $HOME/pkg/mysbo/libcaca
# nano libcaca.SlackBuild
# change --disable-imlib2 to --enable-imlib2 # PS: Install imlib2 first!
# add --disable-docs # if your are having LaTeX issues, as I did
# BUILD=3 ./libcaca.SlackBuild
# upgradepkg /tmp/libcaca*
		

That's it, you now have imlib2 support in your caca applications! Note the BUILD=3 statement, you can adjust the VERSION or BUILD variables manually. The version of libcaca that I was altering was version 0.99.beta18, build 2. If I downloaded a later version of the source code, say 1.0, I could run VERSION=1.0 BUILD=1 ./libcaca.SlackBuild, if this worked I could then edit the SlackBuild and set these values permanently. However we were just rebuilding with different compile options, so we just incremented the BUILD number.

PS: If you make a habit of customizing the standard packages, or if you make a lot of packages yourself, you should probably have a fixed place to put your files. I will not dictate how you should organize yourself, but you might find the following suggestion helpful: I usually place my SlackBuilds in $HOME/pkg/mysbo/name, any source code archives in $HOME/pkg/mysbo/archive, and my binary packages in $HOME/pkg/myrepo. I have installed slackpkg+, and in my /etc/slackpkg/slackpkgplus.conf configuration I have enabled a local repository: MIRRORPLUS['myrepo']=dir://home/user/pkg/myrepo This local repository is added to PKGS_PRIORITY so that my custom packages will always take precedence over the official ones.

Writing a SlackBuild

Because of their simplicity, the Slackware package management tools are surprisingly versatile. You can create and distribute Slackware binaries for virtually anything. As an example lets create a package that installs a new user and populates his home directory with a few files. But this time let's create a proper SlackBuild script. First lets add the files we need:

$ mkdir -p $HOME/pkg/mysbo/guestuser/home/guest
$ cd
$ cp .vimrc .bashrc .xinitrc $HOME/pkg/mysbo/guestuser/home/guest
$ cd $HOME/pkg/mysbo/guestuser
$ tar czf guestuser.tar.gz home
		

We now have a source archive, guestuser.tar.gz, that contains all the files we want in our package. Of course installing a new user is not just a matter of populating his home directory, we also need to register the new user. The easiest way to do so is by running the useradd command, but how do we execute this command from a Slackware package? Slackware packages optionally include an install directory that can contain two files, slack-desc which is a plain text description of the package, and doinst.sh witch is a shell script that is executed after a package is installed.

We can start by creating our doinst.sh:

$ echo 'useradd -m -g users -G audio,cdrom,floppy,plugdev,video\
,power,netdev,lp,scanner -p guest guest 2>/dev/null' >> doinst.sh
$ echo chown -R guest:users /home/guest >> doinst.sh
		

Next we can create a short package description in slack-desc:

$ echo guestuser: This package simply creates a guest user >> slack-desc
		

The slack-desc file requires a specific formatting, which can be a bit annoying, you may find this tool helpful.

Now that all our files are in order lets write the actual build script, open guestuser.SlackBuild in your favorite editor and write:

#!/bin/sh

# First of all lets define the program name, version and such, and a few
# conventions such as where to build the package and place the binary.
PRGNAM=guestuser
VERSION=${VERSION:-1}
BUILD=${BUILD:-1}
TAG=${TAG:-_SBo}
ARCH=any
CWD=$(pwd)
TMP=${TMP:-/tmp/SBo}
PKG=$TMP/package-$PRGNAM
OUTPUT=${OUTPUT:-/tmp}

# Let's be paranoid and exit if anything goes wrong
set -e

# OK, we're ready to actually build the package now. Clean out old files
# and create build directories if necessary, also make sure file
# permissions are correct.
rm -rf $PKG
mkdir -p $PKG $OUTPUT
cd $PKG
tar xvf $CWD/$PRGNAM.tar.gz
chmod -R 644 .

# Lets add the meta files
mkdir $PKG/install
cat $CWD/slack-desc > $PKG/install/slack-desc
cat $CWD/doinst.sh > $PKG/install/doinst.sh

# And then finally we can create the Slackware binary
/sbin/makepkg -l y -c n $OUTPUT/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.${PKGTYPE:-tgz}
		

With this file in place, and assuming you have set up slackpkg+ as previously mentioned (if not use installpkg instead of slackpkg), we can now create and install this package like so:

$ su -
# cd /home/user/pkg/mysbo/guestuser
# chmod +x guestuser.SlackBuild
# ./guestuser.SlackBuild
# mv /tmp/guestuser-1-any-1_SBo.tgz /home/user/pkg/myrepo
# slackpkg install guestuser
		

This SlackBuild is somewhat sloppy, for one it doesn't check if there already is a guest user on the system, but even worse removing this package will only delete a few files in /home/guest, it will not actually remove the guest user. The sysadmin need to manually run userdel -r guest to do that. Nevertheless I hope this crude package demonstrates how easy it is to create such scripts, and how flexible the Slackware package management is.

If you're new to Linux you can be forgiven for thinking that the above script is anything but easy, but most of the commands here are just boiler plate and sanity checks. Templates such as this one only need minor tweaking to build something radically different. Also note that there is nothing inherently special about a SlackBuild, it is just a shell script, in fact the only Slackware specific part of our script is makepkg. Learning to decipher such scripts will teach you a lot about Linux!

Source Code Management - Automatically

Of course manually compiling everything you need by hand is tedious, if only there was a community repo out there where users could submitted and share their SlackBuilds... There is: slackbuilds.org! Not just that, there are also a number of front end applications that lets you install these source-based packages easily. The official one is sbopkg, another good alternative (especially if you like dependency resolution) is sbotools.

PS: If you do go with sbopkg, add packages you want to the queue, don't install them directly. Then consult their READMES and also add any dependencies listed here to the queue (Then consult their READMES and add any dependencies listed and so on ad infinitum...). When your done go back to the main menu, go to Queue, then Sort and Reverse, now you can Process the queue and the packages will be installed in the correct order. A final tip: Run sqg -a and dependency lists will be generated for all the packages in the repo, you can then install a package with all dependencies like so sbopkg -i package

So after downloading sbotools you can for instance do something like this:

$ su -
# installpkg sbotools-2.5-noarch-1_SBo.tgz
# sbocheck
# sbofind steam
# sboinstall steam skype spotify supertuxkart inkscape
# sboremove skype
# sboupgrade --all
		

SlackBuilds.org is a source based community repository of nearly 7000 packages. Think of this repo as reminiscent of the Arch AUR or BSD Ports collection. All of these builds are proof read and tested by the site admins before release. Of course this does not mean that things will work perfectly every time... Non standard additions or configurations to your system can break the build scripts in unforeseen ways and upstream url's might change causing temporary download errors. Nevertheless the overall quality is good.

PS: Security updates installed through slackpkg can cause 3rd party software from SlackBuilds.org to break. If this happens you usually just need to recompile the SlackBuilds.org package(s). Luckily though this does not happen often with Slackware stable, if your running current however, this sort of thing happens all the time. The moral: Don't run Slackware current unless you want to be hassled!

What about a graphical package manager, or a large community repo of binary packages? Well... you can't really get this with vanilla Slackware. There are however a few distros based on Slackware with such functionality, and many of them are binary compatible with Slackware. Some examples are: Zenwalk, Porteus, Salix and VectorLinux.

Alternative Desktops

What if your on board with all the stability and simplicity and stuff, but you find the default Xfce theme in Slackware boring. Xubuntu is much prettier, who cares about stability anyway! Is it time for a distro hop..? Well Xubuntu uses the elementary icon theme and the whiskermenu, in addition to a nice gtk theme, wallpaper and fonts. It would require quite a bit of work if you wanted to tweak Xfce in Slackware to look exactly like Xubuntu, but a fair approximation isn't difficult at all:

  1. sboinstall elementary-xfce murrine-themes ttf-ubuntu-font-family xfce4-whiskermenu-plugin slack-wallpapers
  2. Go to Settings -> Settings Manager -> Appearance in the menu and: set Style to MurrinaBleu, set Icons to elementary Xfce darker and set Fonts to Ubuntu Light with Slight anti-aliasing Hinting
  3. Right click on the panel and: add the whiskermenu under "Add New Items" and replace the default menu, rearrange the panel launchers and such to suit your needs. You may wish to change the panel color under "Panel Preferences" (eg. #93A1A1 and Alpha 80)
  4. right click on the desktop, and choose a cool wallpaper under "Desktop Settings"
  5. Finally you may wish to change the Terminal colors under Edit -> Preferences -> Colors -> Load Presets (eg. Solarized Dark)

Congrats you now have a somewhat Xubuntu-ish looking desktop! Slackware will give you software in its default form, which at times mean you get ugly looking programs. But as this example shows it usually takes a minimum of effort to make things prettier. You may of course want something other then Xfce. The SlackBuilds repo contain quite a few window managers and desktops that you can install with sbopkg or sbotools. For larger more complex desktops more work might be required.

slackpkg+ includes links for a Cinnamon repository (csb), and Mate repository (msb). So after installing slackpkg+ and editing /etc/slackpkg/slackpkgplus.conf to include these repos, you can install these desktops like so:

# slackpkg install csb
# slackpkg install msb
		

slackpkg+ also includes a KDE 5 (aka Plasma) repository (ktown), but installing it is a more involved process since you need to purge and replace the default KDE 4. So read the instructions here carefully (PS: Although possible it is non-trivial to revert back to KDE 4 from Plasma)!

It is also possible to install GNOME 3 (aka Shell), this too is provided by a 3rd party repository. GNOME 3 is a complex piece of software, and as always complex pieces of software can cause all kinds of problems. So it is highly recommended that you install GNOME 3 on a fresh, and default, installation of Slackware! After downloading the PackageKit installer from the dropline project, do the following:

$ su -
# installpkg PackageKit-0.8.17-x86_64-3dl_install.txz
# pkcon refresh force
# pkcon install dropline
		

Conclusions

Some might choose a distro simply because of the way it looks, but does that really make sense when it takes 5 minutes to change a desktop theme? How much fun is a cool looking wallpaper on an unreliable system? At the end of the day a Linux distribution is just a collection of software. Despite what their users imagine, Firefox 58.0.2 on Fedora or Gentoo does not have mysterious superpowers that Firefox 58.0.2 on Slackware or Debian lacks.

At the end of the day the Slackware desktop experience is what you make of it. True, it does not have a huge and well tested repository compared to the likes of Debian, but it likely has what you need (and more). And the time it takes to tweak this distro to suit your needs is well spent, it actually saves time down the road and you have probably learned some useful tricks in the process. To illustrate what you can do with this distro I played around with a few window managers and included their screenshots. I have not included all available desktops, in particular there is a near unlimited amount of lightweight stacking and tiling window managers available for Linux, but I have tried to include a selection that will illustrate the breadth of choices. Also there is almost no end to the limit of configurations you can do on most desktops, the examples shows here are just the result of a few minutes of tinkering. I am sure you can produce prettier (or uglier) setups yourself with modest efforts :)

Screenshots:

KDE

Cinnamon

Mate

GNOME

Plasma (KDE 5)

Ratpoison

LXDE

LXQT

Lumina

Enlightenment 22

Enlightenment 16

CDE

Fluxbox

Blackbox

FVWM

Awesome

NotIon

Icewm

wmii

uwm

WindowMaker

AfterStep

CTWM

Emacs

A Terminal