Ultima Linux’s relationship to Slackware

It is a popular misconception that Ultima Linux is “easy desktop Slackware,” no doubt because sites such as DistroWatch erroneously represent us as such. (I am not aware, incidentally, where they got the description – I did not provide it, and at that time Ultima was actually marketed as a “techie-oriented” system.)

This document will attempt to clarify the relationship between the Ultima and Slackware projects, to prevent further confusion with regard to this issue. It is my hope that this will be the definitive final answer on the topic. With any luck, we should be able to clear up whatever misconceptions happen to exist, and get back to more important things – for example, actual development.

Slackware-derived code

The current Ultima Linux source tree was forked from Slackware-current around April 2006. Most development since then has been done independently. Ultima Linux does not follow any Slackware source tree: We usually take updates directly from upstream sources (i.e. the program vendors), and often apply our own patches to add features not provided in Slackware.

There are several parts of the Ultima source that are borrowed from Slackware, verbatim or otherwise:

Package management. Ultima Linux takes the package management tools directly from Slackware, as there is no other upstream source for these scripts.
Build scripts. When adding new packages, we generally prefer (for consistency, and to avoid duplication of efforts) to use an existing build script as a base. This is not limited to Slackware proper; we also borrow code from third-party packages, when said code is of sufficient quality for our purposes. (Note that Ultima’s build scripts, however, are heavily patched from the originals; see below.)
Source code patches. On occasion, the Ultima developers will borrow a relevant source code patch from Slackware. This is usually limited to patches not available from the program vendor or another upstream source, or Slackware-specific patches (i.e. adding $DESTDIR support to a Makefile). As a side note, a large number of patches have also been taken from other systems, including Frugalware, Arch, Mandriva, Fedora, Gentoo, etc.
Good ideas in general. This is anything that doesn’t fit into the above categories, but nonetheless makes sense. For example, installing KDE in /usr was one change – or in a more abstract sense, even the core ideology of “Keep It Simple, Stupid” has greatly influenced Ultima development.

The things we do not copy include:

Binary packages. Particularly considering Ultima Linux’s requirement of AMD64 support (see below), we do not – and will not – ship binary packages taken from Slackware, or any other source.
Build scripts. Needless to say, we’re pedantic on this one. We rarely copy build scripts verbatim – see below – and we absolutely will not copy any build script that does not meet our quality standards. For example, Ultima Linux does not use Slackware’s build scripts for Mozilla Firefox and Thunderbird, which merely convert pre-existing binary packages; we use our own scripts that build these programs from source.
Upstream sources. Ultima Linux packages generally use the latest stable sources from the original software vendor; we do not take these updates from any other distribution.
Bad ideas in general. This is a relative term, obviously, but there are some things in Slackware we don’t like. Ultima Linux does not include packages we don’t need – for example, a lot of the programs in Slackware that are redundant or merely of “historic interest”. We also tend to be slower than Slackware to make large changes – such as renaming or splitting packages, or building i686-only code – that could have a negative effect on ourselves or our user base. And frankly, we won’t copy anything that (to us) seems outright stupid.

Ultima-specific code

Although we prefer to use existing, high-quality code whenever possible, there are some things that Ultima Linux cannot – or does not – take from other sources. The following code is entirely original work, or otherwise specific to Ultima Linux:

Build scripts. When build scripts don’t exist for packages, we write them – and ditto when build scripts do exist, but aren’t up to our quality standards. Some notable examples include OpenOffice.org and VirtualBox OSE.
AMD64 packages. If you absolutely must insist we’re a derivative distribution, at least give credit where it truly belongs. The majority of our code was re-forked or copied from Slamd64 shortly after the original Slackware fork. And we deserve credit for manually patching and re-building over 500 build scripts and software packages to implement 64-bit support.
“Desktop” features. For example, KDE uses sudo by default for password authentication, and users can read/write Windows partitions from their regular user accounts. There’s also better multimedia support, such as Macromedia Flash, proprietary video codecs, and DVD playback support.
Miscellaneous original code. Probably the “shining star” of Ultima Linux’s original code is xorgmaker, the X.org configuration tool. Most Ultima users aren’t even aware of its existence – and yet it has been acknowledged as possibly the only X.org configurator that actually works. (Maybe I exaggerate...) The LiveCD, incidentally, is also built from entirely original code, as linux-live was not considered of sufficient quality.

A word on terminology

Calling Ultima Linux a Slackware-based distribution suggests that we simply copy Slackware’s code and maybe slap on a few new wallpapers (a la every Ubuntu “fork” out there). This provides a misleading picture of what the Ultima Linux developers do – we aren’t out there to merely copy code, but rather to improve it. Ultima forked from Slackware because it was good code – but we felt it could be better. To say we merely “copy” their work is completely disregarding all our own development efforts.

To prevent further confusion, I would prefer that Ultima Linux be referred to as Slackware-like (similarly to Linux in general being referred to as Unix-like). This helps to emphasize that the Ultima distribution is similar to Slackware – and in many ways, the two distributions’ code is more-or-less interchangable – but also indicates that they are not identical.

Of course, better yet would be to consider Ultima a separate distribution in its own right. Once my Grand Master Plan™ is in place, all other distributions will be obsolete...