Linux Mint 18.3 “Sylvia” and Flatpak

Spread the love

Linux Mint Sylvia, will support Flatpak by default on 18.3.

According to Linux Mint team, the next version 18.3 will support Flatpak by default on the Software manager,

Their reasoning.

The following was extracted from Linux Mint blog:

Flatpak

You might have heard of Flatpak, AppImage or Snap. Three solutions to a common problem.

Before I show you what we did, let me explain the problem very briefly.

Installing bleeding-edge applications in Linux Mint

Linux Mint is an operating system built on a package base which doesn’t change and which is supported for 5 years. That base is Ubuntu LTS, a snapshot in time of thousands of packages maintained by Debian, and a commitment to apply security updates. The result is both very stable and very safe. You get all your software from that base, other than security patches, that software doesn’t change and so it doesn’t break. Everything is great, but there’s a trade-off. You don’t have access to new versions of software applications, you can only run the versions which are in that base. And sometimes these versions can be 1, 2 or even 5 years older than what’s available elsewhere.

Sometimes you can just go on-line and grab the newest.DEB. For instance, you can download Virtualbox 5.2.0 directly from virtualbox.org.

Sometimes it’s more complicated. New versions of the software you want to run might come with new dependencies and depend on packages which are not present in Linux Mint. When that happens, installing the newest.DEB won’t work. To solve that issue, we use PPA (Personal Package Archives), which basically are 3rd party repositories. These repositories contain both the software you want to run, and the dependencies they need to run on your package base (in Linux Mint 18.x, that package base is Ubuntu Xenial 16.04, that’s why you see PPAs marked as supporting “xenial”).

And then sometimes it’s even more complicated than that, because the dependencies the new software needs not only aren’t present in Linux Mint, but they’re not compatible with it, or they would conflict with it and break other things. For instance if a new version of the software you want to install depends on GTK 3.20, you cannot install it via a PPA. GTK 3.20 cannot be installed alongside GTK 3.18 and upgrading GTK would basically break a lot of things already installed in your operating system.

To solve that last case the idea is to run the software in isolation. In its own little environment, separate from the rest of the operating system. It’s a bit similar to what’s done in Windows, when you download apps which aren’t just 5 or 10MB but a whole 500MB or so. They contain their own dependencies and it doesn’t really matter what’s installed on your system (Note to advanced users: I’m vulgarizing a bit here. I’m aware dependencies work much better than that, especially in Flatpak and that they’re not just stuck in the bundle blindly like it’s done when shipping a static build. I’m just trying to explain it in simple words without getting too technical.).

So the idea is for the software you install to use its own version of GTK and its own dependencies. Linux  Mint continues to use GTK 3.18 and to work very well, and that new software you install uses GTK 3.20 without impacting the rest of the OS.

That idea is to allow you to install new versions of software which aren’t available in Linux Mint, without worrying about dependencies or incompatibilities. And that idea, along with other benefits (in particular in terms of security/isolation) has been implemented by a few projects lately. On the gaming side of things, it’s worth mentioning Steam. On the software side of things you probably heard of AppImage and XDG-APP, and more recently of Flatpak (the former XDG-APP) and Snap.

Why Flatpak

The design of one of these solutions looked very promising to us and its implementation is already very stable. We’re hoping to see it gain more momentum, and we’re adding full support for it in Linux Mint 18.3. This solution is Flatpak.

Similar to APT and its deb repositories, Flatpak is a manager which can be configured to point at multiple “remotes”. These remotes host software applications and dependencies (sdks, runtimes. I don’t want to get into the technical jargon in the scope of this post). When you install a flatpak it runs in its own environment and without impacting your OS. Yet, dependencies can be common across multiple flatpak applications.

Flatpak makes it trivial to install bleeding-edge applications on our frozen LTS base. But it also makes it trivial for upstream software editors to distribute their software to Linux users, without having to care about a multitude of distributions and the many bases we have to support (typically in Linux Mint we’re currently supporting both Mint 18.x and Mint 17.x, and software needs different dependencies and different builds for each base).

Flatpak is also flexible and doesn’t rely on a middle-man between the editor and the users. Editors and users can choose to rely on centralized app stores if they wish. But they don’t have to. For instance, an editor could ask Flathub to publish its application but it could also publish it directly, or even create its own store (i.e. “remote”). And downstream users could very well set up their Flatpak client to point to either Flathub or the Editor’s store directly, or both of them even. That flexibility is key and it contrasts with Snap which wasn’t designed with multiple repositories in mind.

Today we have three “containerized” technologies:

Flatpak, Snap and Appstream

Flatpak was made by Alexander Larsson, Principal Software Engineer at Red Hat, and it’s NOT tied to Systemd.

Flatpak builds on several cutting edge technologies. Under the hood, it makes significant use of OSTree, which can be described as “Git for large binaries”. This provides much of the functionality for hosting software repositories. It also makes Flatpak extremely efficient: applications and libraries that are installed with Flatpak are de-duplicated, saving disk space; “static deltas” reduce the size of downloads for software updates.

For sandboxing, Flatpak makes use of the Bubblewrap utility, as well as several Linux kernel features (such as cgroups and namespaces), which helps to make it portable across distributions.

 

Snap was created by Canonical, and it’s used by default on Ubuntu:

 

The snapd technology is the core that powers snaps. It offers a new way to package, distribute, update and run OS components and applications on a Linux system.This section provides an overview to the key concepts and technologies that enable snapd systems, covering:

  • installing snapd on your Linux distribution
  • using the snap command
  • the concept of snap stores where snaps are distributed for both testing and final release
  • the core principals of the snapd system, including the OS snap, transactional updates and application confinement
  • interfaces to enable applications to access OS features or share features with other applications
  • transactional updates that enable snaps to be updated easily and rolled back if needed
  • garbage collection to ensure old versions of snaps are appropriately removed from devices

Appstream

AppStream is a cross-distribution effort for enhancing the way we interact with the software repositories provided by (Linux) distributions by standardizing software component metadata.

It provides the foundation to build software-center applications, by providing metadata necessary for an application-centric view on package repositories. AppStream additionally provides specifications for things like an unified software metadata database, screenshot services and various other things needed to create user-friendly application-centers for (Linux) distributions.

 

Closing words.

With so many options, it might be overwhelming for the new user, but in the end you should use what’s shipped with your distro of choice.

 

Linux Mint Sylvia, will be released on December 2017!!!

 



Add a Comment

Your email address will not be published. Required fields are marked *

five − two =