A failed Bell Labs OS called Plan 9 is hiding inside everything you use

Plan 9 should have been a way bigger deal. After all, it came from Bell Labs, the same place that gave the world Unix and C, and tried to fix a lot of Unix’s broken components instead of just cloning them.

The problem is that almost nobody outside of OS nerds ends up using it. Commercially, it went absolutely nowhere. But while the OS faded into oblivion, some of its ideas are still in use inside software I use every single day.

The Unicode standard UTF-8 was built for Plan 9. Its 9P file protocol still appears in Linux, virtualization, and WSL. Its ideas about files, networks, and namespaces all feel strangely modern now. That’s why I absolutely had to try it out.

I booted Plan 9 and immediately felt lost

This did not feel like “old Linux” or Unix

I started not with Plan 9, but with its maintained fork, 9front. That’s because Plan 9 doesn’t run on hardware even considered old by today’s standards, and I didn’t have any old AMD 775 motherboards with PS/2 ports lying around the house.

I downloaded the AMD64 ISO from the 9front site and quickly learned that even the boot process wouldn’t offer any hand-holding. The first real gotcha was determining which /dev/sdDx was the ISO and which was the virtual disk. In my VMware Workstation VM, the ISO appeared as:

/dev/sdD0

While the virtual disk was:

/dev/sdD1

While there’s nothing abnormal about this, the difference was that there was no friendly disk picker with names, sizes, and an obvious place to install Plan 9. It also meant that I needed to boot from sdD0 (The ISO). Then install onto sdD1 VMDK virtual disk.

I accepted the boot target and started the OS with:

inst/start

Unfortunately, I was met with a mouse and keyboard that didn’t work, and after some investigating, I discovered that I needed to edit /n/9fat/plan9.ini and explicitly tell 9front to use ps2intellimouse:

mouse=ps2intellimouse 

After that, a lot of the installation was simply an exercise in accepting defaults, though not blindly. The key stages are:

partdisk: partitioning of the virtual hard disk and choosing MBR.

prepdisk: preparing the Plan 9 partition for the installer.

mountdisk: mounting the installation files from the ISO at /dev/sdD0/data.

bootsetup: the point at which the boot setup gets written to the hard drive’s 9fat partition at /dev/sdD1/9fat

There wasn’t anything particularly difficult about this, and the prompts made sense because they were so similar to those found on modern Linux installers.

After the installation was complete, I booted from the disk for the first time and saw the Plan 9 rio desktop. I was expecting some kind of variation of early Unix desktops, but what I got was something completely different.

It wasn’t quite as alien as something like Temple OS, but it was still strange. Windows had to be drawn into existence via a three-button mouse setup. There was no friendly app menu, and parts of the live system appeared as files.

Plan 9’s Acme editor is not VIM or Notepad, as it treats text as if it were the interface

Words could save files, open paths, and run commands

At first, Acme looks like a typical text editor. It looks plain, but then I understood after accidentally typing in the wrong area that there’s no separate text, menus, or commands. Across the top of the window is a row of words such as New, Cut, Paste, Snarf, Sort, Xerox, and Delcol. In a normal text editor, I would have assumed these were buttons. In Acme, they’re closer to “executable text.”

And that’s precisely what makes Plan 9 so weird. Acme’s taglines are editable text areas that can also serve as command areas. Middle-clicking (three-button mouse, remember) one of the words actually runs it:

• New creates a new window.
• Snarf is a part of Acme’s copy-and-paste model.
• Xerox creates a clone of the active window.
• Delcol removes a column.

In file windows, commands like Put and Del are self-explanatory, but become an important part of the workflow.

It gets even stranger because the same idea applies beyond the commands and to virtually any text visible on the screen. A file path becomes something that can be opened. A word can be searched for. The text isn’t just content trapped inside the editor. It can be used to navigate and operate the entire system.

You'll need a three-button mouse to interact with 9front. Make sure you use a USB mouse and not your trackpad if you're on a laptop.

Plan 9 took “everything is a file” very seriously

Unix said it, but Plan 9 built the whole house around it

Unix famously made “everything a file”, but Plan 9 takes the same concept to a whole new level. Plan 9 doesn’t just treat documents and devices as files but also processes, networking, services, and system resources. Often as live interfaces rather than files that sit on a disk.

That became obvious and started making more sense once I listed /proc:

lc /proc

Plan 9 treats these as entries that I could browse. When looking inside one process directory, I found that some were read-only views, and others represented a live state that could be edited. Essentially, Bell Labs had decided that files are how programs, devices, and services should communicate, and made that concept almost like its manifesto.

It abandoned the idea of complex APIs and system calls like ioctl in favor of simple read/write operations for pretty much every system interaction. Looking at the original documents from MIT, it seems the original intent was to require all system components to use the same file-based structure. That’s because when everything speaks through files, the same structure can work locally or across a network.

UTF-8 is the least obscure thing Plan 9 gave us

A failed OS helped normalize the text encoding everyone uses

The strangest thing about Plan 9 is that one of its most successful ideas is probably on your screen right now. UTF-8, the text encoding that lets computers handle English, Cyrillic, Greek, Japanese, and so on, without falling apart, was actually created for Plan 9 back in the early 1990s.

UTF-8 works by storing each character as one to four bytes. Plain old ASCII characters stay small and highly compatible, while characters outside that range use longer byte sequences:

Whereas older systems depended on competing character encodings, UTF-8 gave Plan 9 ASCII compatibility while also making room for the rest of the world. So while Plan 9 never became mainstream, UTF-8 absolutely did. In fact, it became the web standard. Almost every modern webpage, including the one you’re reading now, relies on it.

Plan 9’s ghost still appears in modern systems

The OS lost, but its ideas drive a lot of infrastructure I take for granted

Windows, macOS, Android, and iOS aren’t Plan 9 in disguise, but a lot of Plan 9 ideas survived because they solved real problems that still exist.

The easiest example is 9P, which was Plan 9’s original protocol. If you’ve ever used WSL on Windows, P9 is there to ensure Windows can access files in a Linux distro. On Linux, the v9fs filesystem implements 9P support. In QEMU and other virtualization platforms, 9P is used to share folders between hosts and guests.

That’s exactly why my 9front VM didn’t feel like a historical dead end. The same ideas implemented in Plan 9 that I had seen in their strangest form keep showing up in familiar places like remote resources, namespaces, and the underlying tech that makes different views of systems possible.

I, of course, wouldn’t recommend it as any kind of replacement for a modern OS. But after booting it up and poking through /proc and /net, I totally understand why people still talk about Plan 9. It might have failed as a mainstream OS, but it endures today in so many fundamental ways.

That’s why I wanted to run this strange little piece of computing history for myself.