# kem-a/AppManager for Linux AppImage Installation

> AppManager is a GTK/Libadwaita desktop utility written in Vala for installing, organizing, updating and removing AppImages on Linux. It fits users who want desktop integration and several update paths without requiring FUSE, while its sandboxing still depends on optional system tools.

**kem-a/AppManager** — MacOS style AppImage installer and management application

- Repository: https://github.com/kem-a/AppManager
- Stars: 1,534 · Forks: 42
- Language: Vala
- License: GPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/kem-a-appmanager

## What AppManager Changes for AppImage Users

AppManager targets Linux desktop users who download AppImages outside a conventional distribution package workflow. The core problem is not simply running the file. Most AppImages are portable, but a user still needs to decide where to store the executable, create a launcher, associate an icon and remove the application later. AppManager places those operations behind a GTK/Libadwaita interface and presents them through a drag-and-drop window described as a macOS-style installation flow.

The application supports SquashFS and DwarFS AppImage formats. According to the README, it does not require FUSE to run because it uses uruntime. That differs from workflows that expect FUSE to be installed and configured. The README also presents the bundled AppManager application as usable on older Linux distributions and musl-based systems. The source project itself still has a defined dependency list, so that compatibility statement should not be confused with an absence of platform requirements.

The intended audience includes users who want desktop integration, people who keep several versions of the same application and users who prefer applications capable of updating themselves. The repository is not archived, and the last push was on 2026-10-16. The release history lists v4.0.0-beta1 on 2026-10-11, v3.8.0 on 2026-09-02 and v3.7.3 on 2026-07-22. The beta designation remains relevant when selecting a build for routine work.

## Drag-and-Drop Installation and Desktop Entries

The documented installation flow starts by opening an `.AppImage` and dragging it into AppManager. The application then moves the file to `~/Applications`, extracts its bundled `.desktop` file, rewrites the `Exec` and `Icon` values, stores the launcher in `~/.local/share/applications` and copies the icon. The result is an application registered with the desktop environment rather than an unregistered executable that only runs from its original download directory.

Portable installation is the default. The executable remains the application artifact while the generated launcher points to its installed location. An extracted installation is also available through the application details. It places the application under `~/Applications/.installed/<app>/`, which gives the installation a more conventional directory structure without replacing the AppImage with packages from the Linux distribution.

A separate portable mode creates `.home` and `.config` folders next to the AppImage. The README says this lets an application store its data alongside itself. This is a meaningful tradeoff. Such an application can be easier to carry between systems, but application state is no longer confined to the user's normal configuration directories. Users who depend on shared settings or expect a conventional Linux home should inspect this behavior before enabling it for an important application.

The side-by-side installation feature handles multiple copies or versions of one application. Additional copies receive numbered names such as `Bitwarden` and `Bitwarden 2`, with separate desktop entries and icons. The application library adds search, sorting and list or grid views. These capabilities matter most to users managing a growing collection rather than installing one isolated file.

## AppImage Links, Verification and Update Sources

AppManager can act as an `x-scheme-handler/appimg` handler. Its documented link format is `appimg://install?url=…&sha256=…`. According to the README, this path downloads an AppImage over HTTPS and verifies the supplied SHA-256 and size. Downloads matching the AppHub catalog receive the application's sandbox template. Other downloads use the user's normal installation defaults.

The update system is not limited to an updater embedded in one AppImage. It supports zsync delta updates from embedded update information, GitHub and GitLab releases, and plain download links checked for changes. Pre-releases can be included optionally. The README identifies zsync delta updates as a way to reduce bandwidth use, but the optional `zsync2` or `zsync` runtime tool must be available.

Background checks can run daily, weekly or monthly. AppManager can notify the user when an update is available and can optionally install it. Each run is recorded in an update log. This reduces the need to remember individual applications, but it creates a policy decision about unattended replacement. Automatic installation is not the same as automatic recovery. The README does not document rollback, failed-update restoration or a transactional installation model.

Per-application settings include a custom name, icon, keywords, `StartupWMClass`, launch arguments, environment variables, drawer visibility and `$PATH` participation. The README says these settings survive updates. GitHub authentication can raise the stated API request allowance from 60 to 5,000 requests per hour when a personal access token is configured. The token is kept in the system keyring when Secret Service is available. Otherwise, it is stored in an AES-256-GCM blob bound to the machine and user account.

## Running AppManager Through Nix or a Release Build

The shortest documented way to run the project without a permanent installation uses Nix. This command runs AppManager from its GitHub repository and is suitable for an initial evaluation.

```bash
nix run "github:kem-a/AppManager"
```

To install it into a Nix profile, use the documented profile command.

```bash
nix profile install "github:kem-a/AppManager"
```

The README does not provide expected console output for either command. For a release-based installation, it directs users to the GitHub releases page and says to download the latest application version, enable execute permission and double-click it to install it. The exact filename and a permission-changing command are not documented, so they are omitted here.

Building from source requires `valac`, `meson`, `ninja`, `gettext`, `glib-compile-schemas`, GTK 4, Libadwaita, GLib, GIO, Gee, libsoup, libsecret and GnuTLS. Optional `libseccomp` and Wayland development packages support sandbox hardening. The README also includes distribution package commands, such as the following Debian and Ubuntu dependency installation:

```bash
sudo apt install valac meson ninja-build pkg-config gettext libadwaita-1-dev libgtk-4-dev libglib2.0-dev libjson-glib-dev libgee-0.8-dev libsoup-3.0-dev libsecret-1-dev libgnutls28-dev libseccomp-dev libwayland-dev curl zlib1g-dev liblzma-dev libzstd-dev
```

The README does not show the complete source-build and run command in this section, so no additional flags are inferred.

## Sandboxing Features and Runtime Boundaries

AppManager includes per-application sandboxing instead of treating every AppImage as equally trusted. The `Privacy & Security` settings can select `Standard` or `Strict`. The project also provides presets, customizable permissions and AppHub templates. Documented permissions include access to personal files, network, sound, devices and desktop services. A sandboxed AppImage can run with a private home directory.

The project separates its interface from the tools that enforce restrictions. Optional `libseccomp` support provides syscall filtering, while Wayland support uses `wayland-client` and `wayland-scanner` for compositor-side isolation. The README gives these Meson options for disabling those features at build time:

```bash
-Dseccomp=disabled
-Dwayland_security_context=disabled
```

These are build options, not commands entered into AppManager at runtime. Sandbox operation also depends on `bwrap`, `xdg-dbus-proxy`, `fusermount3`, `squashfuse` and `dwarfs`. Their absence can prevent a selected profile from operating as intended even when the core installer remains available.

The README does not claim that every Linux desktop provides identical security semantics. It points readers to `sandboxing/README.md` for profiles, requirements and known limitations. That distinction matters because a preset is not proof that an arbitrary AppImage behaves correctly under every distribution, compositor and runtime. Users should review that guide before treating the privacy controls as a complete security boundary.

## AppManager Compared with Manual and Package-Based Workflows

A manual AppImage workflow usually consists of moving a file, creating a `.desktop` entry, editing `Exec`, placing an icon and checking for updates. AppManager automates those operations and adds a searchable library, metadata customization, multiple versions and background update checks. Its approach is therefore different from leaving each AppImage as an unregistered portable executable.

A conventional Linux package manager remains the relevant alternative when distribution repositories, centrally coordinated upgrades, shared libraries and predictable uninstall behavior matter more than portability. The README does not describe AppManager as a package-manager replacement, and it does not claim that the package formats used by `apt` or `dnf` are handled by AppManager.

Keeping an AppImage in an arbitrary directory and launching it directly is another approach. It requires less management software, but the user remains responsible for launcher paths, icons and update checks. AppManager adds a layer with its own settings, database-like library state, generated desktop entries and dependencies. Its Preferences can move applications when the installation folder changes, although the README does not document recovery from an interrupted move or a rollback command.

AppManager also supports deletion through the interface, the app drawer's `Move to Trash` action or removal from `~/Applications`. The practical choice is between a managed installation with desktop integration and retained update metadata, and a manually managed file with fewer AppManager-managed conveniences.

## Maintenance, Licensing and Upgrade Constraints

The repository is not archived, and the last push was on 2026-10-16. The listed releases include v4.0.0-beta1 on 2026-10-11, v3.8.0 on 2026-09-02 and v3.7.3 on 2026-07-22. This is recent project activity, but the beta designation should still influence the choice of build for a workstation that requires predictable upgrades.

AppManager is licensed under `GPL-3.0`, and the repository contains a `LICENSE` file. This review does not interpret the license or provide legal advice. Anyone repackaging the application should read the license text and assess its own distribution obligations.

Upgrading is not necessarily a matter of replacing one executable. The project stores per-application settings, installation locations, desktop entries, icons, update logs and sandbox choices. Background updates can also replace application files. Users should check release notes for configuration migration instructions before changing an established installation. The README does not document a rollback command or a complete configuration migration procedure, which matters in managed desktop environments.

The GitHub token feature also requires deployment decisions. The README states that the token is placed in a Secret Service-backed system keyring when available. Its fallback is an AES-256-GCM blob bound to the machine and user account, so copying that configuration to another account or system does not make the token portable. The README does not document a migration procedure for moving that token to another machine.

## Conclusion

Choose AppManager if you regularly install AppImages and want a graphical library, desktop entries, update checks and optional per-app isolation. Do not choose it if you require a documented rollback workflow, broad distribution packaging guidance or sandboxing without reviewing the required runtime tools. Verify first that your Linux distribution provides the GTK, extraction and optional sandboxing dependencies, then begin with the stable release and inspect the generated desktop entry before installing important applications.

## FAQ

### Does AppManager require FUSE to run AppImages?

The README states that AppManager does not require FUSE to run and uses uruntime. Some extraction, update and sandboxing features still require separate runtime tools listed in the project documentation.

### How does AppManager install an AppImage?

The documented flow opens an `.AppImage` in a drag-and-drop installer, moves the application to `~/Applications`, extracts and rewrites its `.desktop` file, stores the launcher in `~/.local/share/applications` and copies its icon.

### Can AppManager update applications in the background?

Yes. AppManager supports configurable daily, weekly or monthly update checks, notifications and optional automatic installation. It records each run in an update log, while zsync delta updates require an optional `zsync2` or `zsync` tool.

### Does AppManager provide per-app sandboxing?

Yes. The README describes `Standard` and `Strict` privacy profiles, customizable permissions and AppHub templates. Enforcement can depend on optional tools such as `bwrap`, `xdg-dbus-proxy`, `fusermount3`, `squashfuse` and `dwarfs`.

## Sources

- [Issues](https://github.com/kem-a/AppManager/issues)
- [kem-a/AppManager on GitHub](https://github.com/kem-a/AppManager)
- [License: GPL-3.0](https://github.com/kem-a/AppManager/blob/main/LICENSE)
- [README](https://github.com/kem-a/AppManager/blob/main/README.md)
- [Releases](https://github.com/kem-a/AppManager/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kem-a-appmanager