matttproud.com (blog)

Iconography of the X Window System: The Boot Stipple

Zürich, Schweiz

If you are of a certain vintage, this image is burned indelibly somewhere in your posterior parietal complex:

640 x 480 of “root_weave”

Oh, my old friend. How it’s been a long time.

Cultural Significance

For the uninitiated, what are we looking at? Could it be the Moiré Error from Doom? Well, no. You are looking at (part of) the boot up screen for the X Window System, specifically the pattern it uses as the background of the root window. This pattern is technically called a stipple.

What you’re seeing is pretty important and came to symbolize a lot for me as a computer practitioner. Over time, I came to develop a relationship with it roughly as this:

[…] if you gaze for long into a stipple, the stipple gazes also into you.

What would compel me to say that?

Well, part of it is nostalgia, but the other part is practical. For a long time the X Window System had a reputation for being difficult to configure. In retrospect, I’m not 100% sure why it earned this reputation to the extent that it did, because the configuration file format, which is plain text, has remained essentially the same since I started using Linux in the mid-1990s. On the other hand, the amount of hand-written input required for the configuration file has fallen gradually over time. Therein lies the popular critique, I suspect: the amount of information that needed to be gathered. In the old days, it used to be that mouse, keyboard, video card, monitor, fonts, plugin+module data, etc. needed to be spelled out in detail in /etc/X11/XF86Config. If you were starting out with a bare configuration file (e.g., after a fresh install of a system), researching the necessary parameters for your hardware could be a real pain in the ass. In this era, I had dial-up Internet, and Google wasn’t a thing yet.

And this leads to to an interesting observation: you wouldn’t want to wing it with the configuration, because allegedly you could break your monitor with a bad Monitor setting. That never happened to me or my friends, or at least none of my friends ever fessed up to it happening to them. What I will confess to is giving my monitor a bad case of electrical whine on a few occasions. Here is an example Monitor setting found in an XF86Config file from Red Hat 5.0 (1997–8) vintage) to give you an idea of just the level of detail required for the monitor:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Section "Monitor"
  Identifier "My Monitor"
  VendorName "Unknown"
  ModelName "Unknown"

  # HorizSync is in kHz unless units are specified.
  # NOTE: THE VALUES HERE ARE EXAMPLES ONLY.  REFER TO YOUR MONITOR'S
  # USER MANUAL FOR THE CORRECT NUMBERS.

  HorizSync 31.5

  # VertRefresh is in Hz unless units are specified.
  # NOTE: THE VALUES HERE ARE EXAMPLES ONLY.  REFER TO YOUR MONITOR'S
  # USER MANUAL FOR THE CORRECT NUMBERS.

  VertRefresh 50-70

  # Modes can be specified in two formats.  A compact one-line format, or a
  # multi-line format.
  #
  # These two are equivalent:
  
  # ModeLine "1024x768i" 45 1024 1048 1208 1264 768 776 784 817 Interlace
  #
  # Mode "1024x768i"
  #   DotClock 45
  #   HTimings 1024 1048 1208 1264
  #   VTimings 768 776 784 817
  #   Flags "Interlace"
  # EndMode
EndSection

Did your blood pressure raise looking at that? Mine did. Remember: this information wasn’t a casual Google Search away for many of us back then.

So what does this have to do with the stipple I mentioned earlier? Combine the onerousness of configuration above with the fact that computers weren’t particularly fast, and the answer will become clear. I recall in the era that the X Window System took on the order of — what felt like — tens of seconds to start even for relatively simple window managers like twm. We were using spinning disks, after all! So it could take a while to get the X Window System properly configured through trial and error. Misconfiguration could mean any of the following:

As I have gotten older, I became acutely aware that one of the most important things that matters for technical learning and productive use is a tight edit-run cycle1; and that’s where the stipple comes in. That stipple above is the first thing that the X Window System would display on startup if things were going reasonably well with the X Server and its configuration. So seeing that meant you knew the things were at least partially (if not most of the way) working. And that was because it could take multiple seconds longer for the window manager to follow with its startup. Heaven forbid you were starting a full-blown desktop environment in this era.

Was this the stipple’s actual purpose? I’m frankly uncertain. I’d hoped that someone would have written about this already, but nobody really has — at least that I could find. The best I found is a whimsical historical excerpt from the OpenBSD FAQ:

We test as above, and… SUCCESS! We have what appears to be a very nice, high resolution display. Note that ALL that is expected is a mesh pattern (very good for seeing how good your monitor REALLY is and also great for calibrating LCD displays, called the “root weave”) and a movable cursor. It is not intended to be functional at this point.

Nevertheless, given OpenBSD’s reputation of being a methodical project, I’m inclined to give the FAQ authors some credence. The early smoke testing success signal combined with implicit branding seem like as good of a guess as any.

Fast Forward to Today

So why write about something that seems purely like an indulgence? Surely the stipple still lives with us today and requires no further discussion? Well, up until the early-2010s (at least on the Linux distributions I was using), this boot up scene was common to see — until it suddenly wasn’t.

Linux distributions had a reputation for not being particularly bleeding edge with the packages they contained. So to my surprise one day this startup behavior just stopped. I took note of it, but I never researched why (life comes at you fast, and I was distracted by more important things: moving abroad, starting a family, starting a new job, etc).

So why did the stipple go away? I’m not terribly certain to be honest (there was no central bug tracker2), but I’ll posit some guesses based on the contextual history:

There was a desire in the mid-2000s to 2010s to improve the boot speed of Linux and its overall accessibility to newcomers. Canonical was sinking a lot of cash into Ubuntu as well as Mir. This was also happening in the backdrop of systemd’s development. In short, there was concerted momentum to modernize the ecosystem.

According to my detective work, in September 2008, a commit lands (0bb317a78b96fddcdac319c9706b3a12f931ea44) in the X.Org server that adds a flag to the X Server called -retro that backs a global variable called party_like_its_1989. This commit removes the default stipple and the customary X_cursor behaviors from boot, which look like this:

X Window System starting up

Looking at this, the global variable’s name alone tells us the sentiment: out with the old; in with the new. I’m just surprised it took several years for the new default behavior to land in whatever distribution I was using at the time, which is why I made the remark above about distributions not having been super bleeding edge. Why did it take until the mid-2010s for me to notice the disappearance?

Thinking aloud, the flag’s help description of "start with classic stipple and cursor" doesn’t really do a good service to the reader. Let me give you a concrete formulation of what I mean: have you ever encountered the word “stipple” before reading this, and did you already know what the word means? I don’t want to be unkind to the maintainers, but I think this flag’s description is probably lost on a majority of readers (probably intentionally so).

Getting our Stipple Back

All of this talk about the stipple’s evoking a desire to bring it back. So how do we do that in modern software? Do you still use startx to start your X Server? I’m guessing not; but if you did, it’s as easy as:

1

startx -- -retro  # note the preceeding -- to provide options to the X Server

To make that permanent with startx, you could amend your ~/.xserverrc file to include the -retro flag:

1
2
3
4
5

cp -i /etc/X11/xinit/xserverrc ~/.xserverrc
cat ~/.xserverrc
#!/bin/sh

exec /usr/bin/X -nolisten tcp" "${@}"  # add -retro before the -nolisten

And of course a similar workflow as the above can be applied to all users on the system if you amend the /etc/X11/xinit/xserverrc file.

If you are using GNOME Display Manager (GDM), you appear to be out of luck with due to the /usr/libexec/gdm-x-session shim not providing a mechanism to pass through arbitrary options to the X Server.

Users of X Display Manager (XDM) can amend /etc/X11/xdm/Xservers file to include the -retro argument à la:

1

:0 local /usr/bin/X :0 vt7 -retro -nolisten tcp

Users of LightDM can amend the /etc/lightdm/lightdm.conf file such that it includes the following stanza:

1
2

[Seat:*]
xserver-command = /usr/lib/xorg/Xorg -retro

I’m sure there’s a way to do this with SDDM, but it won’t install on my machine due to a networking problem.

Failing that, you can always use xsetroot to just replace your root window’s background.

But — wow — isn’t that a fuck-ugly fractal of fragmentation? I mean, I get on a technical level why each thing that is managing the X Server takes a different approach (independent development by individual engineers with different design philosophies and requirements), but this just a stupid amount of toil to pass a measly flag. I guess it’s a shame that X.Org went the flag route and didn’t expose a mechanism in the X Server’s configuration file.

Definition of the Stipple

So how is the stipple defined? Is it defined as a file (asset) for the X Server to load at runtime? This part sent me on a goose chase. I did not discover commit 0bb317a78b96fddcdac319c9706b3a12f931ea44 until relatively late in my research, and it would have simplified my research into this question.

Herein lies some fun duality; the stipple is defined both:

For startup, however, the X Window System only uses the static source code definition (the data backing the _back_lsb or _back_msb variables from dix’s window.c based on your machine’s endianness).

Behold, the stipple has a real name: root weave!

Note: The definition of the root weave bitmap data literal and that of the file appear to be different.

History of the Root Weave

Now, if you clicked the link for root_weave above, you probably noticed an interesting detail: this file was last changed approximately 20 years ago. So it’s old, right? Well, this is where things get most interesting in my opinion.

Not that long ago, we celebrated the X Window System’s 40th birthday! And this led to me wonder: could we determine the introduction of root weave?

I worked backwards:

So, I think we can conclude that root weave hails from somewhere between June 1984 (X1) and February 1986.

An Ecosystem of X BitMap Files

It turns out that root weave is not the only X BitMap file that comes installed, and there are a bunch of other ones that are about as old as it. We have some other weaves:

And there are plenty of others bitmaps (some newer). I made a quick contact sheet using ImageMagick:

1
2
3

montage -verbose -label '%f' -font "Go-Mono" -pointsize 10 \
  -background '#000000' -fill 'gray' -tile '4x5' -border 5 \
  -bordercolor '#888888' -auto-orient $(echo * | sort) /tmp/contact.png

I’m certain there is some fun and weird history with these images. Is there anyone around who can recount it, though? The one that caught my eye was “woman”. OK, why is there one called “woman,” and why is it so aesthetically different from the rest? By coincidence, in my research I came across the release notes for X11R1; it hints that “woman” was used to demonstrate a regression in the server’s code:

With the “woman” bitmap, the small images are corrupt on color screens (server bug likely). The program dumps core when colors are specified in .Xdefaults.

…

Among other things, try the command “xsetroot -bitmap include/bitmaps/woman”.

Curious.

Other Detours

Seminal software often inspires and influences other software. Sometimes these others are derivative products. A good analogue for this are derivative game engines and the tree they form (e.g., Quake I derivatives). This exercise prompted a whole bunch of fundamental history questions around software provenance and lineage to which I didn’t have the answer:

Revisiting the Era with Fresh Eyes

Playing around with several old versions of Linux and adjacent ecosystem software provided an opportunity to see if the good ol’ days were in fact any good. Well, to be honest, this was some rough software to work with. A lot of creature comforts that I am used to are not there (e.g., no -r flag for grep), and the overall user experience is extremely unpolished. If we take a step back from configuring the X Servers of that era and look at how the servers are bootstrapped in terms of how startx and friends are implemented, wow, it is a lot more complicated (e.g., serverargs and clientargs machinations that look well intentioned but also incredibly fragile).

To counterbalance that, I have to say in spite of some improvements in the intervening years, Linux and X seem like an accretion disk. Not enough acquired complexity was shed.

I will remark that in spite of my job being a software engineer, I had never spent a lot of time looking at the source code for the X Server (XFree86 or X.Org) before. It’s really nuts to see that a lot of the architecture from X10R3 and X11R1 still persists in the code today, which is a statement that can be said in deep admiration for legacy code but also disturbance from the power of old decisions. Without having looked at the internals of any Wayland implementation, I can sympathize sight unseen with the sentiments that some developers have toward the X Window System: the code is a dead end. I say that with the utmost respect to the X Window System as a technology and an ecosystem. I’ll keep using X, and I will be really sad when it’s no longer possible for me to do so for one reason or another, as I’m extremely attached to it quirks. But it’s clear the future is limited.

Our Lost Futures

We could have ended up with a different default stipple. The images above with cross and wide weave hinted at that.

Here’s what it would have looked like with some of the other fun contenders from the included bitmaps:

And taking things in a more absurd direction, let’s consider Windows 3.1 with respect to the stipples above. Windows 3.1 had a very strong design language in my mind — as did Windows NT up to and including Windows 2000. It also turns out that Windows 3.1 (maybe even Windows 3.0 if memory serves) had a bitmap-style background pattern feature that included a pattern composition tool. So I took a stab at making the weaves in the editor:

Windows 3.1 Pattern Composer

Interesting, what would have Windows 3.1 have looked like with these weave patterns? Let’s find out!

All of this leads me to wonder what would Edward Tufte have said about the original X ecosystem and its aesthetics. A lot of it was spartan and clear, yet there is some gratuitous administrative debris here and there (like this stipple).

Closing Words

Diving deep into this gave me a lot of joy — and a great chance to revisit the past. In case of errors, omissions, or other cool details, get in contact with me.

So knowing now that root weave and all of that is from 1986, should I send X.Org a pull request to rename the party_like_its_1989 global variable to party_like_its_1986 or party_like_the_1980s.5. Something tells me they wouldn’t welcome it.

  1. Can you guess why I like the Go Programming Language so much? A tight feedback loop is exhilaratingly addictive. ↩︎

  2. I’m certain that if I were to trawl IRC logs or other mailing lists (which ones: probably something GNOME-related), I’d find the reason. So here I am, guessing … ↩︎

  3. I discovered something tragic. The CVS servers for XFree86 had been taken offline; there’s no canonical commit log available for historical research! The best I found was a mirror that someone cobbled together: https://gitlab.freedesktop.org/ajax/xfree86. So take it with a grain of salt. ↩︎

  4. Metro Link looks like a fascinating company. I’d love to know their history. I tried reaching out to their co-founder, but he never responded. If you look at the Project Athena - X Window System Users and Developers Conference of 1987, you’ll see plenty of commercial collaborators with the project, so it leads me to wonder what kind of other cottage industries there were. Surely the X Window System server market wasn’t flooded with many commercial choices. ↩︎

  5. This assumes the zapping (CTRL+ALT+Backspace) and the default X cursor on boot also date from 1986, but I have good reason to suspect they do. ↩︎

Navigation:
Tags: