Linux gives you plenty of ways to install software: native distro packages, Flatpak, Snap, AppImage, source builds, even curl-piped installers. The catch is that each one solves a different problem, yet none of them fully eliminates the “works here, breaks there” reality across all distros.

Package Forge (PkgForge) is a new project with a narrower mission: deliver truly distro-independent portable applications that run the same way across systems. In other words:

“I want the same app to install and run across different distros, without fighting dependency and packaging differences.”

In this article, we’ll not only discover exactly what Package Forge is doing, we’ll dive into the inevitable comparison: how does this differ from Flatpak, Snap, and regular AppImages?

The Basic Premise

The Package Forge home page, pkgforge.dev

PkgForge’s primary focus is portable and/or statically built software that minimizes reliance on distro-provided dependencies. I’m saying minimizes (not eliminates) because some requirements are hard to avoid in practice, especially around portable image formats, where features like FUSE or unprivileged user namespaces may come into play.

A truly “dependency-free” packaging format is difficult to achieve in the absolute sense, but PkgForge aims to get as close as realistically possible. Before we get into what PkgForge does, we need to understand why it exists and why this project is so important.

Universal Packaging Isn’t Quite So Universally Supported

Universal packages are like plugs — they need to fit the socket or nothing will happen. Pexels / Castorly Stock

Universal app packaging for Linux seems solved, but the reality is a bit more messy than it could be. For example, both Flatpaks and Snaps require a set of helper components, if you will, to be installed on your system. Without that support in place, a .snap file is about as useful as downloading an .exe without Wine.

Flatpak is slightly different: it doesn’t rely on the same kind of always-on daemon as Snap, but it still requires Flatpak support to be enabled on the host. Furthermore, Flatpak apps rely on runtimes being available (granted, Flatpak can install them for you). Either way, you’re not dealing with a single self-contained executable that you can run on any Linux system anywhere.

Most Universal Packaging Isn’t Built to Be Portable

Containerized systems have become a bridge between distros, but haven’t truly solved the portability problem. You can’t freely pick them up and move them around. Pexels / Kaique Rocha

Most popular distros ship with Flatpak installed (or at least readily available), and Ubuntu, which by way of popularity remains firmly in its own lane, has Snap preinstalled and configured. But what happens if you want to take those same Flatpak or Snap apps with you to another system, or keep your favourite apps on a bootable USB and run them anywhere?

Well… not quite. You can move Flatpaks around and even install them offline, but the system you’re using still needs Flatpak support. With Snaps, you still need snapd installed, and most distros don’t. So neither approach lets you simply pack up your apps and run them anywhere with zero host components in place.

Why Not Just Use Regular AppImages?

Pexels / Leeloo The First

You could use AppImages for this, sure. In fact, this is the very problem AppImage was created to solve. In many cases, it really is the closest thing Linux has to a true “download once, run anywhere” model.

However, “portable” does not always mean “portable everywhere.” AppImages can still make assumptions about the host system, and those assumptions are not guaranteed across every distro, security context, container, or older environment. Even on modern desktops, a change in configuration can be enough to turn “works for me” into “why won’t this launch?”

And even if portability were perfect, AppImage still leaves the “everything around it” problem. You are often on your own when it comes to finding trustworthy builds, keeping them updated, and integrating them cleanly into your desktop.

• Where do you find reliable builds?
• How do you keep them updated?
• How do you ensure clean desktop integration?
• How do you ensure trust?

These Are the Problems PkgForge Solves

No more leaving portable packages lying around Pexels / Ekaterina Belinskaya

PkgForge covers just about all the problems we’ve identified with universal, portable packaging for Linux. It’s not a new packaging format in and of itself, nor is it trying to replace AppImages. Instead, it’s an ecosystem that publishes portable packages and static binaries in curated repositories, paired with a package manager designed to install and manage them.

One of the ways PkgForge stands out from some portable app efforts on Linux is its focus on accessible documentation and a security-minded distribution model. The project primarily delivers prebuilt binary packages, keeps transparent build logs, and relies on checksum verification.

This helps reduce the spread of ad-hoc install scripts and the need for local compilation, which has long been a common pattern when downloading Linux software directly (and still is for many projects today). To make life easier for the end-user, the project maintains its own frontend, called Soar.

What Is Soar?

Soar is PkgForge’s package manager, built to install and portable software across distros in a consistent way. It serves as a companion alongside your distro’s own package manager, rather than seeking to replace it. It pulls from PkgForge’s own caches, and other compatible sources, and manages desktop integration through freedesktop.org specifications, including menu entries and icons.

Soar also adds installed applications to your system PATH, allowing them to be called from the CLI or other applications with just the name of the binary. It aims to keep things relocatable so your setup can be moved between systems more easily. It also keeps things clean by using consistent install locations, so you don’t end up with a downloads folder full of random executables you can’t track.

Behind Soar, there are a number of other components that make the PkgForge ecosystem functional.

SoarPkgs: Recipe-Based Packaging

The main user repository of PkgForge, called SoarPkgs, contains build recipes written in the .SBUILD definition format, which is the project’s own packaging recipe system. These .SBUILD files act as portable descriptions of what the software is, where to get it, and how to turn it into something Soar can install.

They usually practical metadata for the build process and desktop integration details where relevant (app ID, icon, desktop entry). PkgForge also provides tooling to lint and build these recipes, such as SBuilder, so packages use repeatable processes for publishing in their curated repositories.

BinCache: Statically Compiled CLI Tools

PkgForge also maintains BinCache, a collection of pre-compiled static binaries that users can install through Soar. This part of the project focuses on command line tools in particular, making it easier to grab software that can be distributed as a single self-contained binary, without needing to compile it yourself or rely on distro repositories.

PkgCache: Portable Desktop Apps (and More)

PkgCache is PkgForge’s repository for portable application packages, especially desktop (GUI) software. Rather than betting on a single universal format, PkgForge distributes whatever best fits the software at hand, with AppImage as just one payload type among several.

What Kinds of Packages Does PkgForge Use?

• AppImage (+zsync): standard AppImage releases, sometimes paired with zsync metadata for more efficient updates.
• AppBundle: a portable “bundle” style package that ships an app as a self-contained directory structure.
• Archive: classic tarballs/zip archives, typically used when upstream already ships a portable bundle or when the simplest approach is best.
• FlatImage: a portable image format designed to be app-like and more predictable across systems.
• GameImage: a game-focused portable format intended for larger, asset-heavy software.
• RunImage: a single-file, container-like portable format intended to run apps in a more controlled environment.
• Static binaries: single-file command line tools compiled to run with minimal or no external library dependencies.

How to Use PkgForge

Pexels / Ann H

If you’re interested in using software from the PkgForge ecosystem, there are two straightforward approaches. Soar is the recommended solution, which you can use like an additional package manager, and let it handle installation, updates, and system integration. It also allows you to search for apps and utilities without having to dig through the repos online.

💡

Want to see all the packages available through PkgForge? Visit: https://pkgs.pkgforge.dev/ to get a full list, organized by repository.

Alternatively, you can search the PkgForge repos manually, and download and manage individual portable packages on your own. This is preferable if you’re building a portable toolkit on a USB drive, testing a single app temporarily, or simply want full control over where files live. Just keep in mind that you’ll also be taking on the responsibility of handling updates, cleanup, and desktop integration, if needed.

Example Usage: Soar

Soar is a CLI utility and works much in the same way as apt, dnf, and others. We won’t cover everything here as there’s a lot that could be covered. Full details on how to achieve this are provided in the Soar documentation.

Finding Packages

To find packages with Soar, use the search command:

soar search search-query

Searches query package names, package ids (pkg_id), and other metadata.

Installing & Updating applications

To install an application, you can either use soar install package-name or on of its aliases, for example:

# Using the "i" alias
soar i package-name

# Using "add" alias
soar add package-name

You can also install packages through more granular controls, using package ids or even choosing to install an app from a particular repository.

Like most popular tools, you can also chain package names together to install multiple packages at once, with a familiar syntax: soar install package1 package2 package3. Soar also supports both --force and --yes flags, though caution is emphasized when using the latter.

Soar has a simple update command, soar update which takes any number of package names as an argument and provides no additional flags or aliases.

Removing Applications

Removing applications with Soar is just as straightforward as you’d expect. The remove command works, or you can also use aliases:

# Using "remove" command
soar remove <package>

# Using "r" alias
soar r <package>

# Using "del" alias
soar del <package>

Using Applications Temporarily

Soar wouldn’t be a portable application package manager without this handy feature. You can download and run applications temporarily, without system integration, by using the run command. Just use soar run package-name and it will download the necessary package and run the command without setting up any .desktop files or adding it to your PATH.

This makes Soar a great tool for both managing packages you actually want, and trying out the system if you’re just curious.

Is Anyone Using It?

It doesn’t seem that many projects are using PkgForge to host their primary binary distributions as yet. However, there seems to be quite an active community effort around the project, including the AnyLinux AppImage collection. These packages are designed to automatically detect whether FUSE or user namespaces are available, and if not, fall back to extraction before running, eliminating the primary issue with AppImages.

Many popular apps are available through this effort and can also be installed with Soar in most cases.

Some of the popular apps available as AnyLinux AppImages (and installable with Soar) include:

• Ghostty (soar install ghostty)
• OBS Studio (soar install obs-studio)
• Transmission-qt (soar install transmission-qt)
• EasyTAG (soar install easytag)
• Android Platform Tools (soar install android-tools)
• Citron (soar install citron)
• Cromite (soar install cromite)
• Sudachi (soar install sudachi)

Final Thoughts

Portable apps have always played an important role in desktop computing, and on Linux they’ve long been a stress point. With PkgForge, we might finally be getting closer to cracking this problem, at least in practical terms. Even if it doesn’t replace Flatpak, Snap, or AppImage, it helps give definition to what a more flexible, truly distro-independent future for portable Linux apps could look like.