Tracing the Evolution of Containerization Technologies

From Chroot to Docker

Tracing the Evolution of Containerization Technologies
Photo by Paul Teysen / Unsplash

The age of containerization has revolutionized software development, with Docker emerging as the leading technology in this domain. However, the road to Docker was paved by a series of innovations that laid the foundation for modern containerization practices. Let's trace the history of technologies that contributed to the birth and rise of Docker.

Chroot: The Grandfather of Containerization

The story of containerization begins with chroot, a Unix system call first introduced in 1979. Chroot is often considered the grandfather of containerization, as it introduced the concept of creating isolated environments on Unix-based systems.

Bill Joy, one of the key developers of BSD Unix, first implemented chroot. The original purpose was to create a test environment for building and installing software packages without interfering with the host system. By changing the apparent root directory of a running process and its children, this provided a simple form of isolation, preventing processes from accessing files and directories outside the specified environment. However, it had limitations. For instance, chroot did not isolate processes at the kernel level or restrict resource usage, such as CPU and memory. Despite these limitations, chroot laid the groundwork for more advanced containerization technologies to come.

FreeBSD Jails

In 2000, FreeBSD introduced Jails, an extension of the chroot concept. Poul-Henning Kamp, a Danish computer scientist, developed the Jails feature to address some of the limitations of chroot and further enhance security and isolation.

FreeBSD Jails extended the idea of isolated environments by creating virtual environments that function almost like independent systems within a single host. Each jail has its own file system, IP address, hostname, users, and process space. Jails can run multiple applications with different dependencies, configurations, and network settings, all within isolated environments on the same host.

This lead to improved security, resource limits, simplifying system administration, scalability, and portability. Despite these benefits, FreeBSD Jails were specific to FreeBSD-based systems and were not directly compatible with other Unix-based systems like Linux. The concept of FreeBSD Jails marked a significant milestone in the evolution of containerization, demonstrating the value of isolating applications and processes within independent environments.

Solaris Zones and Containers

Sun Microsystems introduced Solaris Zones (also known as Solaris Containers) in 2004 as a major feature in the Solaris 10 operating system. The goal was to address the need for better process isolation, resource management, and system efficiency.

Solaris Zones built upon the concepts introduced by earlier containerization technologies by providing even stronger isolation and more comprehensive resource management capabilities. This was driven by the increasing complexity of applications and their dependencies, as well as the growing concerns about system security and resource efficiency.

By creating isolated virtual environments within a single operating system, Solaris Zones enabled the running of multiple applications with different dependencies and configurations without interfering with each other. Each zone functioned like an independent instance of the Solaris operating system, sharing the same kernel but with its own file system, network configuration, and process space.

Solaris Zones demonstrated the value of lightweight virtualization and strong isolation in managing complex applications and enhancing system security which influenced the development of later containerization technologies.

Linux Containers (LXC)

In 2008, LXC emerged as a vital step towards the modern concept of containerization. The primary goal behind LXC was to provide a lightweight, efficient alternative to full virtualization, enabling multiple isolated Linux environments to run on a single host.

LXC leverages two crucial Linux kernel features: cgroups (control groups) and namespaces. Cgroups, introduced by Google in 2006, allow the management and allocation of system resources, such as CPU, memory, and I/O, to specific processes and their descendants. Namespaces, on the other hand, provide isolation by partitioning system resources like process IDs, network interfaces, and file systems, ensuring that processes in different namespaces cannot directly interact with each other.

Although LXC represented a significant step forward in containerization technology, it had some limitations. For example, LXC focused primarily on system-level containerization and did not offer built-in support for application-level containerization, which simplifies application deployment and dependency management. Despite this, LXC played a crucial role in the evolution of containerization technologies. Its incorporation of cgroups and namespaces set the stage for more advanced containerization solutions which now dominate the containerization landscape.


Developed by Cloud Foundry in 2011, Warden was a container management system that built upon the principles of LXC while focusing on a more user-friendly experience. Cloud Foundry, an open-source Platform as a Service (PaaS) project, created it to address the needs of its multi-tenant platform, which required efficient resource isolation, management, and monitoring.

Warden introduced several key features and improvements over LXC, making it an important milestone in the evolution of containerization technologies:

  1. Pluggable Backends: Warden was designed to be extensible and support different containerization technologies. While it initially relied on LXC, Warden's architecture allowed for the easy integration of other backends, such as Docker, which eventually replaced LXC as the default backend for Cloud Foundry.
  2. RESTful API: Warden introduced a RESTful API for managing containers, enabling developers and administrators to create, destroy, and manage containers programmatically. This API provided a higher level of abstraction and made it easier to work with containers in various languages and environments.
  3. Resource Limiting and Monitoring: Warden expanded upon LXC's resource management capabilities by allowing administrators to set resource limits on CPU, memory, and disk usage for containers. Additionally, Warden provided built-in monitoring capabilities, enabling administrators to track container resource usage and performance over time.
  4. Container Snapshotting: Warden introduced container snapshotting, which allowed administrators to create snapshots of running containers and restore them at a later time. This feature enabled easy backup and recovery of container states and simplified application migration between hosts.
  5. Multi-Tenant Isolation: Warden was specifically designed to support multi-tenant environments, providing strong isolation between containers and ensuring that applications in one container could not access or impact resources in another.

While Warden was a significant step forward in container management and provided essential features for Cloud Foundry, it did not gain widespread adoption outside of the Cloud Foundry ecosystem. Looking backward, we of course can see how Docker built upon Warden's foundation and addressed some of its limitations to quickly became the dominant containerization technology.

Google's Contributions: cgroups and lmctfy

We are getting closer to the last pieces of the puzzle with Google's contributions.

Google played a critical role in the advancement of containerization technologies. In 2006, as mentioned with LXC, they introduced cgroups (control groups), a kernel feature that enabled developers to allocate and limit resources to processes, such as CPU and memory. Cgroups laid the groundwork for effective container resource management.

In 2013, Google released lmctfy (Let Me Contain That For You), a container management system that built upon cgroups and namespaces. Lmctfy focused on providing an efficient and reliable solution for managing containers at scale, significantly influencing the development of Docker.

The Birth of Docker

Wow. We are here.

In 2013, Solomon Hykes and the team at dotCloud developed Docker as an open-source project. Docker built upon the foundation laid by previous containerization technologies and introduced features such as a user-friendly CLI, a portable and efficient container format, and the concept of Docker images and registries. These innovations made Docker an accessible and powerful tool for developers, leading to its widespread adoption and dominance in the containerization landscape.

In 2014, Docker Inc. officially pivoted from a PaaS provider to focus solely on the development of Docker and related technologies.


The evolution of containerization technologies, from chroot to Docker, represents a series of innovations aimed at providing developers with efficient, lightweight, and isolated environments for running applications. Docker, with its user-friendly interface, efficient container management, and extensive ecosystem, has emerged as the leading technology in this domain. However, it's crucial to remember the contributions and advancements made by previous technologies that paved the way for Docker's success. This journey highlights the importance of continuous innovation, as each technology built upon its predecessor's strengths and addressed its limitations.

Today, the containerization landscape is evolving rapidly, with projects such as Kubernetes, OpenShift, and Rancher further building on the capabilities introduced by Docker. As the technology continues to advance, it is essential to acknowledge and appreciate the rich history of containerization and the many innovations that have shaped it, allowing us to appreciate the challenges that have been overcome and anticipate the exciting new developments on the horizon.