Exploring Endless OS: A Package-Free Linux Distribution

In the early days, when UNIX was just starting to make its mark, there was no third-party software and no associated management issues. If you needed to install an application, you simply compiled it and placed the resulting binary in the /bin directory.

As the number and complexity of applications increased, problems began to emerge. An application could consist of more than just a single binary; it might include various libraries, man pages, configuration files, and more. This led to the idea of using an install target in the app’s build instructions (Makefile) to set up everything needed with a single make install command.

This system functioned effectively until UNIX became mainstream and started to splinter into various forks and clones. The issue was no longer about ease of installation; it was that there were now numerous applications that often depended on each other and required modifications to work properly in different UNIX-like operating systems.

This is how the BSD Ports system was born. Essentially, it was a collection of scripts that allowed users to download, patch, compile, and install applications automatically. Furthermore, it provided a way to correctly uninstall applications, ensuring that no residual files were left behind in the system.

The beauty of the ports system lay in its ability to not only install and remove applications compiled from source code but also to generate binary packages from that same source. It soon became clear that users found it much more convenient to install pre-built packages rather than wait for compilations to finish. Thus began the era of package managers.

In Linux distributions, the package manager is the de facto standard. Unlike BSD systems, which have a clear separation between the indivisible base system and the collection of ports/packages installed on top of it, GNU/Linux distributions are entirely made up of packages. The kernel is one package, the basic set of command-line utilities is another, and the libc library (the main part of the system after the kernel) is yet another package.

This division isn’t coincidental; it’s the essence of GNU/Linux—a collection of components created by different people working together. However, this approach comes with numerous challenges. Keeping track of package dependencies is crucial; changing just one system package can render the whole system inoperative. Upgrading the distribution to a new version often requires elaborate workarounds: all the core components must be updated in a way that prevents the system from getting stuck in a transitional state (where some packages are updated while others are not).

And of course, the well-known limitation familiar to Linux enthusiasts: you just can’t install two different versions of an application. The contents of a package are copied to system directories rather than their own dedicated ones, and even if installation in a dedicated directory is possible, dependency issues will likely arise. For example, the application requires the libxyz.1.2 library, but the system has libxyz.1.3 installed, and you can’t downgrade it because the package manager will complain that applications abc and bca specifically need version 1.3.

In short, it’s complicated. However, there are several methods to tackle these issues today, all of which are implemented in Endless OS.

Endless OS

Endless OS is the creation of the young company Endless Mobile, which focuses on producing affordable compact computers for developing countries. A typical target user of Endless Mobile is someone from a remote African village, where even mobile connectivity is considered a luxury. That’s why the Endless Computer is designed to be not only affordable but also intuitive and easy to use, without requiring internet access.

The full version of Endless OS is about 14 GB and comes with over 100 everyday applications, more than 50,000 Wikipedia articles, as well as various educational programs. There is also a basic version that is 2 GB, which includes only the essentials. Additional resources can be installed from the app store.

Endless OS uses a heavily modified version of GNOME called EOS Shell as its desktop environment. It’s designed to be very straightforward, lacking many features found in standard desktop interfaces. This environment resembles a tablet or smartphone interface more than a traditional desktop: it includes a task switching panel with a system tray, a collection of icons and folders on the desktop, and a search bar that performs searches both on Google and the hard drive simultaneously.

The installer matches the desktop environment—straightforward and doesn’t bombard you with unnecessary questions. The first boot kicks off with an interactive tutorial video that walks you through the interface, showing you how to find everything, listen to music, watch videos, and install third-party software.

The 2 GB software bundle is quite standard: it includes Google Chrome, LibreOffice, Totem video player, Rhythmbox audio player, Shotwell photo viewer, Duolingo for language learning, a file manager, calculator, settings (the usual GNOME settings), and a terminal (which can only be launched through the search feature).

The app store is user-friendly. Simply click “install,” and the app will be installed without a single question or a request for superuser permissions. All apps are distributed as self-contained packages. The installer places them in the /var/lib/flatpak/app directory, and when launched, it sets up a virtual environment for the application to run in (we’ll discuss this in more detail later).

OSTree

Endless OS does not use a package manager or individual packages. The core part of the distribution, which is the system itself weighing in at about two gigabytes, is a single, monolithic, indivisible piece. Unlike other distributions, you can’t swap out or remove certain parts or uninstall unnecessary software. It’s a unified system, similar to how Windows or macOS operate.

Unlike Windows and macOS, the core of Endless OS doesn’t maintain a fixed state. Instead, all its files are stored in a Git-like repository called OSTree. This means that updating to a new version of the distribution doesn’t occur “live” as it does in other systems where updates are directly applied to the active system. Instead, the eos-updater downloads the modified files into the repository and then creates hard links to them in the root directory. For example, /bin/bash in Endless OS is simply a hard link to a file in the /ostree/repo repository. If bash is updated as part of the system update, eos-updater will remove the old link and create a new one pointing to a different file in the repository.

Compared to the traditional package-based approach, OSTree offers several advantages. It enables atomic updates, meaning the system doesn’t switch to a new updated state until it is entirely ready. In a typical Linux setup, interrupting a package installation can leave the system in an inconsistent state, potentially rendering the OS unusable and needing a full reinstallation. With OSTree, such issues are avoided.

Moreover, because OSTree maintains a history of changes, it allows the operating system to roll back to a previous state. In other words, the system enables a downgrade without the need to download or reinstall anything. The entire process takes just a few seconds.

Lastly, although Endless OS doesn’t support this, OSTree allows you to create multiple installations of different versions of the same OS. All their files are stored in a single repository, so you won’t have to use up extra disk space.

Flatpak

The base installation of Endless OS is read-only. You can’t modify it, which means you can’t install packages or build applications from source using the command ./configure && make && make install. Instead, Endless OS uses self-contained Flatpak packages for software installation.

Flatpak is a modern implementation of a concept as old as Linux itself: applications should be installed in isolated directories rather than mingling their files with the system’s. Beyond just placing applications in their own folders, which allows for the installation of multiple versions of the same app and resolves dependency issues, Flatpak creates a sandbox for each application. This sandbox utilizes namespaces, cgroups, and seccomp to restrict and manage the app’s access to different system resources. For instance, you can deny an application access to the network or limit its view of the file system to the user’s home directory.

All applications installed via Flatpak are located in the /var/lib/flatpak directory. When a Flatpak application starts, it dynamically sets up the environment it needs to run. Specifically, a root file system is created in memory (tmpfs) just for the application, with the system’s /usr directory mounted in read-only mode, along with /proc, /sys, and /dev directories with a restricted set of device files. An /etc with a minimal set of necessary configuration files is also set up. Access to potentially “dangerous” system calls is restricted using seccomp. If needed, the user’s home directory is mounted with read and write access, allowing the application access to required OS functionality.

An application run using Flatpak is isolated from the main system and operates within its own environment. While it does have access to directories like /usr, it cannot modify them. It cannot see the processes running on the main system, does not have access to users’ personal files (by default), cannot interact with the hardware, and cannot escape its virtual environment.

However, because of these same sandboxes, Flatpak becomes ineffective when it comes to system applications. This is why Endless OS is divided into two parts: one is the core system, and the other is a set of Flatpak applications running in sandboxes.

Conclusion

Endless OS is not the only operating system that uses OSTree for atomic updates. OSTree is also the basis for Atomic, an OS designed for running containers, and for meta-updater, a system for atomic updates of embedded systems built with the OpenEmbedded framework.

However, Endless OS appears to be the only consumer operating system that utilizes this technology. It’s also the only OS where all third-party software is installed using Flatpak.

Endless OS essentially showcases what a Linux distribution designed solely for desktop use can be like. It features a simple and intuitive interface, with an indivisible core OS that includes a minimal set of necessary software. It’s very easy to install and hard to break during updates, with all third-party applications running in sandboxed environments and installed in their own directories. It’s the perfect desktop for users who aren’t particularly tech-savvy.