Linux is a big and rich ecosystem, but one of the annoying things about how flexible it is as a platform is the disparity that can appear between using the different flavors of Linux out there. Even app compatibility can be a problem, because distros like Debian and Ubuntu support DEB packages, others like Fedora may use RPM packages, and others still may just rely on a package manager, and even those package managers are different between distros. There are "cross-platform" packages like Flatpak, but not every app is available in that format.

So what if there was a system that could run all of these app types at the same time, and even added support for Android apps for good measure? That's where Vanilla OS 2 comes in, and it's kind of amazing. I spent some time with this platform and came away very impressed with what it can do and how easy it is to use.

What is Vanilla OS?

A container-based operating system

Vanilla OS 2 is a project maintained by many contributors, but the primary driving force behind its existence is an Italian company called Fabricators, and it's meant to be a sort of all-in-one solution that can do anything you'd want. It's a Debian-based immutable operating system that uses GNOME for its desktop environment, and it's also container-based, which is the key reason behind its capabilities.

While Vanilla OS is the main operating system you'll be using, this container-first approach means you can essentially run any Linux distribution inside Vanilla OS, along with all the apps it supports. This isn't something only Vanilla OS does — you can set up a tool like Distrobox to do something similar on any Linux distro — but here, everything is configured out of the box so it's as seamless as possible. You can quickly start using a wide range of apps from different Linux flavors, but I'll get to that in a bit.

Reliability is also a big part of the promise, as Vanilla OS uses the ABRoot tool to ensure the platform is immutable and atomic, making it so updates don't result in configuration drift and potential issues down the line. The container-based approach also makes it so you can create separate environments for different workloads, so files from one project don't end up causing issues with another. On top of all this, Vanilla OS also promises to get out of the way by using smart updates to ensure resources aren't taken up when you need them for something else.

At first glance, it looks like a one-size-fits-all solution. It's reliable, versatile, flexible, and non-intrusive.

Using all your apps

Yes, it is possible

The big feature that makes Vanilla OS stand out is that you can easily install apps from all different Linux distros and package managers through the power of containers, but all of this is unified thanks to Apx. Apx is the dedicated "package manager" in Vanilla OS, but it also serves as a frontend for Distrobox, which in turn uses Podman for creating and managing containers on your system. Apx comes configured with "stacks" for Ubuntu, Fedora, Arch, Alpine, and a couple of other Linux containers, so you can create subsystems (or containers) based on those stacks, and then start installing apps on them. You can also create new stacks that have both a base image and some preinstalled apps, so whenever you create a new subsystem based on that stack, you have a set of packages you might need for any given workload.

Apx lets you manage your containers from their own terminal and use them that way, so you can have full access to the commands and tools installed within each container. You can have multiple containers based on the same stack, so you can have multiple Ubuntu systems with different tools depending on the projects you want to work on, without having to mix everything together. Everything remains separated so there's less of a chance of breaking things.

However, Apx also offers a deeper level of integration than a standard Distrobox setup would. You can use Apx in your native terminal in Vanilla OS to install apps in any of your containers using their default package managers. So, instead of opening a container and using its own terminal, Apx can install an app directly inside that container, but also "export" it so that it becomes available directly within Vanilla OS, whether it's a command line tool or a graphical application. For example, I was able to install the Fedora version of VLC for media playback, but I also installed the Arch version of Steam, and both apps are accessible directly in the Vanilla OS desktop. It's honestly very impressive and really cool to see, even though I noticed that the default scaling seems a bit small for containerized apps, at least on this display.

This did take me a while to figure out because when you look this up, the first page you'll likely see is a blog post where it seems like the implementation was different initially and you could just directly call different package mangers via flags. The proper documentation has the right commands to use, so it's easier to start there. Either way, the concept here is fantastic, and the execution works once you learn the process of getting it to work.

It's more messy than it should be

There are a few issues here

On top of running your typical Linux apps from all different kinds of distros, Vanilla OS tries to go even further by also supporting Android apps, and it even supports easy sideloading by simply opening an APK file downloaded in the desktop environment. Well, at least that seems to be the goal, but I was unable to get this to work. Any commands related to the Android subsystem just don't work, and nothing in the documentation seems to point me in the right direction.

I tried to reinstall Vanilla OS to see if I had missed a configuration step, but by all accounts, it seems as though Waydroid should be set up by default, yet it simply isn't, with no information available on how to get it set up properly. While the operating system itself seems to be continually getting updates, some of the documentation is outdated and the website looks poorly maintained. There hasn't been a new blog post since Vanilla OS 2 launched in September of 2024, and documentation for updating the system still refers to the previous major release of Vanilla OS, even a year and a half later.

Vanilla OS accomplishes its main goal of offering a containerized system that lets you run apps from any Linux package manager, but some of the things surrounding it make it harder to trust the reliability and long-term support of the platform. If you run into any issues, it might be hard to find a solution for them, so it's hard to recommend as the all-in-one simplified solution it aims to be.

There's potential here

Despite the problems I had with the Android side of things and some the misleading information on Vanilla's website, I did manage to get the cross-platform apps working and it is a more seamless experience to have it all brought together by Apx. That integration makes for a more cohesive experience than you'd normally get, and it's easy to get started. If that same principle applied to Android apps the way it's supposed to, I would be singing the praises of this platform.

Still, I'm a big fan of the potential on display here. If these issues were ironed out, I could see some very clear use cases for Vanilla OS, especially as a platform for newcomers who might not be ready to deal with the compatibility problems that can come with some Linux distros. Hopefully the team can flesh things out a bit more and turn this into an experience everyone should try out.