Docker's secret ingredient came from a 1992 operating system that almost nobody used

Published Aug 18, 2026, 9:00 AM EDT Simon is a Computer Science BSc graduate who has been writing about technology since 2014, and using Windows machines since 3.1. After working for an indie game studio and acting as the family's go-to technician for all computer issues, he found his passion for writing and decided to use his skill set to write about all things tech. Since beginning his writing career, he has written for many different publications such as WorldStart, Listverse, and MakeTechEasier. However, after finding his home at MakeUseOf in February 2019, he would eventually move on to its sister site, XDA, to bring the latest and greatest in Windows, Linux, and DIY electronics. One of the coolest parts of Linux is that it's built upon decades of user effort. Something we do, or use, or install today could have fingerprints on it that have survived longer than some of Linux's younger users. However, as much as the Linux kernel and each distro it powers have rich histories, there's also a lot to be said for its software. For instance, did you know that Docker, the software people use to run apps in containers, has roots in an operating system that not many people have ever heard of, let alone used? Plan 9 set the stage for per-process namespaces It started all the way in the 20th century Our story begins in the late 1980s. A team at Bell Labs, including Unix creator Ken Thompson and researchers like Rob Pike, Dave Presotto, and Phil Winterbottom, began working on a new operating system heavily influenced by Unix. What they invented was called Plan 9, which arrived in universities in 1992 and got a more public release in 1995, receiving updates all the way until 2015. It even had a mascot, Glenda, which you can see above. This is where the seeds of what would become Docker were planted. See, in traditional Unix, every piece of software and service shared the same system-wide view of the filesystem and all its resources. If software needed access to a path or device, it had to share that view with everything else. Plan 9 was different. With Plan 9 came the introduction of per-process namespaces. Instead of having software rely on the core resources, per-process namespaces allowed it to construct an isolated view of the system files and devices. Now it didn't have to share; it could use the resources given especially to it. Linux took Plan 9's excellent system and ran with it Good ideas don't need to die out Unfortunately, Plan 9 didn't achieve the success that other operating systems enjoyed. Unix ended up being too much of a powerhouse, and Linux was coming into fruition. However, that doesn't mean that Plan 9's per-process namespaces went to waste. In fact, when 2001 rolled around, Linux developer Al Viro began working on bringing Plan 9-style per-process filesystem namespaces to Linux. In Linux 2.4.19, Viro brought his invention to the Linux kernel. He called it "Mount Namespaces," and just like Plan 9's implementation, it allowed processes to mount drives or directories without a different process seeing it. This hit the Linux scene in a big way, and over time, new namespaces popped up. This included: The Process ID (pid) namespace, which let processes have their own process trees, The Network namespace, which allowed processes to have their own network interfaces, IP addresses, and routing tables, And the User namespace, which lets processes map user IDs so a process can act as root inside its own namespace without having actual root privileges on the main host system. By 2013, Linux had namespaces down to an art form. But, as you know, there's more to this story. Docker took Linux's idea to the next level Because why not take it further? The Linux namespaces worked great, but they were a little complicated for regular users to use for themselves. It wasn't great for someone who wanted to build an app that came with all the dependencies bundled in with it, which would allow it to run properly across different Linux systems. So, one developer named Solomon Hykes of dotCloud announced in a five-minute lightning talk at PyCon 2013 that he was working on a little program called Docker. Docker built a developer-friendly system on top of Linux's existing container technologies, including namespaces and control groups (cgroups). Developers could bundle dependencies within a container (which, at the time, featured LXC and Linux kernel primitives) and allow them to distribute apps with ease. Docker took off because it nailed three key areas: It invented the Dockerfile, which gave developers an easy-to-follow recipe for building container images, It simplified the CLI, allowing developers to skip the complex kernel stuff and use simple commands (like 'docker build') to make containers, And it introduced the Docker Hub, which allowed developers to share their work. Over time, dotCloud would rename itself to Docker, Inc., and the rest is history. Docker's history goes back further than you'd think When you spin up a Docker container on Linux, you aren't just using tech announced back in 2013. You're using the same ideas that were cooked up at Bell Labs in the late 1980s by the best minds behind Unix. Plan 9 may never have taken over the desktop, but its spirit lives inside containers running on the internet today.