Not-a-Linux distro review: SerenityOS is a Unix-y love letter to the ’90s

If this desktop doesn’t look hauntingly familiar to you, you either didn’t live through the 1990s—or perhaps just didn’t live through them right.

Jim Salter

If this desktop doesn’t look hauntingly familiar to you, you either didn’t live through the 1990s—or perhaps just didn’t live through them right. Jim Salter

SerenityOS’s built-in theme support will, like much of its UI/UX, look instantly familiar to anyone who lived through the 1990s.

Jim Salter

SerenityOS’s built-in theme support will, like much of its UI/UX, look instantly familiar to anyone who lived through the 1990s. Jim Salter

Here we see SerenityOS’s Windows Explorer-esque file manager and its text editor—which manages to keep looking like Notepad despite Markdown support and two-frame design.

Jim Salter

Here we see SerenityOS’s Windows Explorer-esque file manager and its text editor—which manages to keep looking like Notepad despite Markdown support and two-frame design. Jim Salter

SerenityOS’s built-in theme support will, like much of its UI/UX, look instantly familiar to anyone who lived through the 1990s. Jim Salter

Here we see SerenityOS’s Windows Explorer-esque file manager and its text editor—which manages to keep looking like Notepad despite Markdown support and two-frame design. Jim Salter

SerenityOS’s console and System Monitor apps continue its overarching theme of instantly familiar framework, populated with new and entirely different data.

Jim Salter

If you aren’t unreasonably excited about the idea of a built-in font editor, I’m not sure we can be friends.

Jim Salter

You want Minesweeper? SerenityOS has Minesweeper. Like everything else, it’s a complete rewrite under the hood.

Jim Salter

Today, I test-drove an in-development operating system project that seems almost disturbingly tailored to me specifically: SerenityOS. I cannot possibly introduce SerenityOS more accurately than its own website does:

SerenityOS is a love letter to ’90s user interfaces with a custom Unix-like core. It flatters with sincerity by stealing beautiful ideas from various other systems. Roughly speaking, the goal is a marriage between the aesthetic of late-1990s productivity software and the power-user accessibility of late-2000s *nix. This is a system by us, for us, based on the things we like.

Every word of this introduction is almost surgically accurate. To someone in SerenityOS’s target demographic—someone like myself (and likely many Arsians), who grew up with NT4 systems but matured on modern Linux and BSD—SerenityOS hits like a love letter from the ex you never quite forgot.

SerenityOS isn’t Linux—and it’s not BSD, either

What that brief intro doesn’t get across is the scale of the project. You might think that SerenityOS is just a Linux distro with an unusually ambitious vaporwave aesthetic, but it’s actually an entire operating system built from the ground up. That means custom-built kernel, display manager, shell… everything.

According to founding SerenityOS developer Andreas Kling, there is absolutely no third-party code in SerenityOS. “When we started,” Kling told Ars, “we imported four or five C standard library functions from NetBSD or something like that. But those were gotten rid of over time. We’re free of third-party code now, with the exception of the build process.”

The build process Kling refers to is something you’ll need to get familiar with if you want to test-drive SerenityOS. There aren’t any actual releases at this point, and there’s no ISO file to download. Instead, you’ll need to git clone the project onto your own machine and compile the OS from source. This produces—and automatically runs—a special SerenityOS virtual machine.

Although SerenityOS doesn’t use code from either Linux or BSD under its hood, it does borrow a couple of concepts from FreeBSD—its license (2-clause BSD), and a “ports tree” software management system similar to FreeBSD’s.

There is a catch to SerenityOS’s implementation of the ports tree, though: it does not operate within SerenityOS itself. Instead, the user builds the port on the host operating system, then rebuilds the SerenityOS image to include the freshly built port.

“It’s a Unix system! I know this!”

On the minus side, SerenityOS’s browser threw an exception—on the plus side, that Crash Reporter is a thing of beauty!

Jim Salter

On the minus side, SerenityOS’s browser threw an exception—on the plus side, that Crash Reporter is a thing of beauty! Jim Salter

Behold the Utah Teapot—a sort of “Hello World” for 3D rendering.

Jim Salter

Behold the Utah Teapot—a sort of “Hello World” for 3D rendering. Jim Salter

Building SerenityOS also automatically fires up its custom VM, leaving a running console log on the host. (Ext2? Yikes…)

Jim Salter

Building SerenityOS also automatically fires up its custom VM, leaving a running console log on the host. (Ext2? Yikes…) Jim Salter

Behold the Utah Teapot—a sort of “Hello World” for 3D rendering. Jim Salter

Building SerenityOS also automatically fires up its custom VM, leaving a running console log on the host. (Ext2? Yikes…) Jim Salter

Although I had technically never used anything in SerenityOS before, the system felt immediately familiar. Unixlike consoles, stack traces, and hardware information blend seamlessly with simple, ’90s-era tabbed interfaces—if you’re familiar with both Windows NT and with any vaguely modern Unixlike operating system, you’ll be familiar with SerenityOS from the moment you see its desktop.

Heck, SerenityOS looks enough like Windows NT to be Windows NT at first glance. It even includes a theme system that looks and works incredibly like the ones found on late-90s era Windows operating systems. But inside the old-fashioned Start menu, simple window dressings, and aggressively plain system font are Unix underpinnings used to good effect.

In a console, a fully featured shell similar to Bash awaits. The shell has many of the system utilities you’d expect to find on a Unixlike system—including but not limited to find, grep, and sysctl. If you manage to crash one of SerenityOS’s applications—and if we’re honest here, you probably will—the Crash Reporter dialog looks like one on Windows. It features, however, a stack trace, contents of the CPU registers, and environment variables in a simple tabbed interface.

My least favorite feature of SerenityOS is its current filesystem, which self-reports as “Ext2FS.” Linux’s ext2 filesystem was pretty good for its time—it’s just that time ended in 1998. I hope SerenityOS eventually gets a more modern filesystem, with proper journaling support for powerloss/crash safety.

1990s-era performance… in a good way

The system is also fast, in much the same way NT 4.0 was fast in its day. And SerenityOS’ performance is consistent in a way that operating systems haven’t seen in a long time. For the moment, SerenityOS’s kernel is not Symmetrical Multi-Processing (SMP) aware—its special virtual machine only uses a single thread of your host computer’s physical CPU.

Obviously, a lack of SMP support will limit the system for many real-world tasks. SerenityOS is only able to get away with its single-threaded model because the entire thing was built with that expectation, but that expectation forced Kling and the contributors who came later to write exceptionally clean, cruft-free code.

The result of this single-threaded environment?  Beautiful simplicity. SerenityOS can’t run any faster than a single CPU core of your host computer does—but it doesn’t run any slower, either.

Although SerenityOS is currently limited to a single thread, Kling tells us that he’s working on upgrading the kernel. “For the last two weeks, I’ve been working on multi-core support… [but] it’s still not stable enough for everybody to live on it. So far, the system usually deadlocks within a few minutes [if SMP is enabled].”

SerenityOS isn’t Linux or BSD. So what is it?

It’s almost impossible to overstate the difficulty of creating an entirely new, reasonably modern operating system from scratch. Very few people or even teams have done it. The most obvious counterexamples are Haiku—a project which aims to recreate BeOS—and the rather more enigmatic TempleOS.

The late American programmer Terry A. Davis developed TempleOS and released it in 2013 as a sort of “modern x86-64 Commodore 64.” I don’t know of anyone besides Davis who actually used TempleOS seriously, since Davis—who was diagnosed with schizophrenia—designed it according to principles revealed in manic episodes he interpreted as divine revelation.

Although TempleOS felt downright alien, SerenityOS feels intuitive and accessible. Like TempleOS, however, it explores new paradigms that aren’t possible or practical in operating systems with a long tail of backward-compatibility and “because it’s always been done this way” thinking.

Usually, the differences in design principle matter more to SerenityOS’s developers than its users. You might notice that the ping utility says “Pong from” instead of “Bytes from” when receiving returns, but these differences don’t make a big impact. There are exceptions, though, such as the spreadsheet application. That uses JavaScript instead of traditional spreadsheet syntax for its formulas. Yes, you heard me—you write your spreadsheet formulae in literal JavaScript!

Some of the paradigm shifts Kling and fellow contributors have introduced are neither weird nor trivial, though. SerenityOS’s kernel, for example, exposes its internals as JSON rather than unstructured text. System utilities consuming kernel information therefore have a much simpler time of formatting it for display and/or internal decisions.

Why create SerenityOS?

When I asked Kling why he decided to write an operating system entirely from scratch, he had two answers. The first, pragmatic answer was he wanted a daily driver operating system for himself, by himself. Other users and developers were welcome, but—initially—they were largely showing up for the ride.

The second answer is that SerenityOS started as a personal therapy project. Kling is a recovering addict, and he decided to build an operating system as a long-term project to focus his mind and occupy his time, similar to the way someone else might decide to build a car or house.

Although Kling still considers SerenityOS to be his eventual daily driver, he’s expanded the scope of “who it’s for” from “me” to “us”—where “us” includes all the people who have shown up, taken a liking to the project, and decided to pitch in.

A growing team

SerenityOS’s contributors page on GitHub shows contributions from 475 people as of this week. Though none come close to Kling’s own millions of lines of code, quite a few contributors have hundreds or even thousands of commits.

“It’s been a process to get used to other people having control,” Kling told me. “It’s really nice [to have so much help] now, but I had to do it in steps—because that initial loss of control is really scary.”

Kling described significant project leadership and training efforts as well. “Hundreds of contributors have put their time and love into this system. It’s been amazing for me to watch people who were apprehensive and didn’t feel they could hack in C++ becoming really competent in the language.”

On top of perfecting the project itself, Kling now tries to mold his newbie contributors into “well-rounded” developers, too. For instance, he’ll often give “gentle nudges” to someone interested in the browser to also work on something inside the kernel or in the graphics stack.

When will SerenityOS be ready?

Although SerenityOS is complete enough to feel like “a real OS” already—with, among other things, a functional network stack—it’s not ready for normal users today. But since SerenityOS has a firm goal—to be the daily driver for “us,” meaning Kling and the small army of developers who have since joined him—I asked if he had any idea when it might be ready for him to use in production at least.

Kling thinks SerenityOS will be ready for his own day-to-day OS needs in “maybe a year or two.” With a focus on native applications built from the ground up rather than ports from other operating systems, that means he—or his fellow developers—will need to write a significant amount of new software, not just hack on the OS stack itself.

“I’ll probably have to write a webcam driver and a video editor,” he said. “I publish to YouTube, so video editing and maybe audio editing are two things I’ll need personally.” SerenityOS’s homegrown browser will need some more work, also—it can’t successfully play YouTube videos yet.

The browser problem

The browser problem isn’t unique to SerenityOS, of course. The lack of a fully functional modern web browser also cripples the Haiku project, and it is surprisingly difficult to resolve. Porting a modern browser like Firefox or Chromium to an entirely new operating system is arguably as difficult as writing one from scratch, and it’s a never-ending project given the rapidity with which web standards and browser technologies evolve.

Fortunately, this isn’t Kling’s first browser rodeo—he told us that he worked on web browsers for Nokia and others for many years. He also has the advantage of being able to build a web browser that’s only a web browser, something that isn’t always possible with older operating systems.

“It’s been really liberating building a new web engine from scratch,” he said. “[We get to employ a] ‘green field’ approach—our browser only needs to support browsing the web and doesn’t need to support anything else.” (As an example of the “something else” which had frustrated him in the past, Kling mentioned macOS Mail support built in to Safari.)