"AM"/"AppMan" is a set of scripts and modules for installing, updating, and managing AppImage packages and other portable formats, in the same way that APT manages DEBs packages, DNF the RPMs, and so on... using a large database of Shell scripts inspired by the Arch User Repository, each dedicated to an app or set of applications.

AppMan is a redistribution of "AM" that does not require root privileges to install and manage apps.

AppMan is part of "AM", so it would not be possible without the contribution of the following authors

NOTE: This repository is just a guide to using the "AM" package manager without root privileges.

As a result, you won't find any code here outside of an "appman" transition script that automatically replaces its own content with APP-MANAGER script's content (hosted in the "AM" repository) once it's started.

Issues, discussions, and code contributions are only possible in the "AM" repository, and are reflected there.

Before reading further, please visit the "AM" repository

https://github.com/ivan-hc/AM

...to better understand AppMan and how it works.

If you're interested in learning more about why there are two repositories for the same program (and why this is just a "secondary" repo), continue reading using the index below.

• What is AppMan?
• What does it do?
• What is this repository?
• Where is the source code?
• Where to report a problem?
• How to add code?
• If "AM" and "AppMan" have the same code, why a separate repository?
  • History
• How to install "AppMan"?
  • How to uninstall "AppMan"?
• Advantages of AppMan over "AM"
• Disadvantages of AppMan over "AM"
• How apps are installed
• Structure of the "AppMan" installation
• Guides and tutorials (external links)
• Related projects

AppMan is a portable version of "AM", limited to installing and managing apps only locally and without root privileges.

The command name changes, from am to appman, but the script is the same.

"AM" on the contrary, provides a "fixed" installation, but can install and manage apps both locally and at the system level.

I recommend "AM" to privileged users who want to install and manage apps at multiple levels, and "AppMan" to non-privileged users who do not have large needs.

All "AppMan" does is download the installation scripts from the "AM" database and then convert them for a local installation, in your $HOME directory, following the paths you indicated when you first launch this CLI.

This repository is just a guide to using "AppMan", and is specific to "AppMan".

The source code can be found at https://github.com/ivan-hc/AM

For any Issue, go to https://github.com/ivan-hc/AM/issues

For any Pull Request, go to https://github.com/ivan-hc/AM/pulls

"AppMan" has been an active project since the second half of 2021, and was a completely standalone script, with an at times troubled history before allowing the birth of "AM".

In the beginning, AppMan was a completely different project than the one you know today, and was intended to be used with root privileges.

The first version of AppMan installed all programs in /opt/bin, then linked them to /usr/bin, and saved the launchers in /usr/share/applications. It was a mess. Given my inexperience, I disregarded the standards and LSB specifications, creating a new one. There was no shortage of criticism.

I had to rewrite the program, but I already had many users at the time. I couldn't suddenly overturn the project.

So I decided to archive AppMan and rewrite a new project, "AM," that respected these specifications: each program had its own dedicated directory in /opt. Initially, links and launchers remained in their positions, but were later moved to /usr/local/bin and /usr/local/share/applications, respectively. The launchers had "AM" in their names to distinguish them from other launchers of the same name.

It was a success, especially in terms of contributors.

One day, in "AM", someone opened an issue asking for a way to install and manage the apps locally, without root privileges.

I had always taken a root approach to "AM" and its predecessor, but I decided to give it a try. Based on my experience at the time, I thought it necessary to write a version of "AM" in another repository, but one that pointed to local paths, chosen by the user.

At time, AppMan had been archived for less than two years, so I decided to unarchive it to rewrite it completely on the base of my experience with "AM"! Just as "AM" was a rewrite of the original AppMan, designed to adopt a structure consistent with Linux standards, AppMan itself became a "fork" of "AM", converted for local use. I copied the contents of APP-MANAGER, the main "AM" script, into "appman," changing the app paths and adding a prompt to allow users to customize the destination directory.

Initially, these changes resulted in duplicate work, leading each AppMan version to be released days or weeks later than AM in an attempt to adapt the code for local use.

I had tons of repositories by now, and my workload had increased both on GitHub and in real life. I needed to simplify my life, and the best way to do that was to make AppMan and AM as similar as possible... or even one and the same.

A major refactoring effort was then launched, aimed at increasingly narrowing the differences between AM and AppMan.

Finally, starting with version 5, released in December 2023, the "AppMan" code merged with "AM", becoming a single script, named "APP-MANAGER", with two different behaviors depending on how it is installed and/or renamed.

This repository is what remains of the transition.

All the work is done at https://github.com/ivan-hc/AM, and dozens of users have contributed to improving this program.

Despite this, there are still blogs and videos referencing this repository, which, as I mentioned at the beginning, is secondary to "AM". This doesn't do justice to the dozens of developers who have decided not only to contribute, but also to participate in the cause: making AppImages great, providing them with sandboxing, centralization, and ease of installation and updating.

In a world where the most starred projects are the most visible, AppMan is a step backwards from the reality that "AM" has managed to become.

It's therefore important to distinguish between "AM" and AppMan in terms of projects:

• "ivan-hc/AM" is the main project, from which all the community work comes.
• "ivan-hc/AppMan" is merely a guide maintained by me, as a single user, given the insistence of many people on linking to this repository instead of the other one

I want to emphasize these aspects, out of infinite respect for my contributors to the AM repository, who deserve due recognition. And there are many of us.

PS: I know the dual existence of these repositories is confusing, and it's worth clarifying why I continue to maintain both. I thank everyone who fell in love with AppMan, but precisely because AppMan is what it is today, let's give due credit to "AM," which embodies the work and passion of dozens of other developers. I don't want the small number of contributors to this repository to mislead others into thinking that all the work is done by one or two people at most.

To install "AppMan" you must first install the "core" dependencies from your package manager:

• "coreutils" (contains "cat", "chmod", "chown"...);
• "curl", to check URLs;
• "grep", to check files;
• "sed", to edit/adapt installed files;
• "wget" to download all programs and update "AM" itself.

Copy/paste the following one line command to download and run the "AM-INSTALLER" script

wget -q https://raw.githubusercontent.com/ivan-hc/AM/main/AM-INSTALLER && chmod a+x ./AM-INSTALLER && ./AM-INSTALLER

...below, the screenshot of what will appear.

Type "2" to install "AppMan", or "1" to install "AM". Any other key will abort the installation.

The above script will place the command appman in your local "$PATH", at ~/.local/bin (this path is the recommended one, since it allows AppMan to be updated in bulk with all other programs, using Topgrade.

Installation is complete!

Run appman -h or go to "https://github.com/ivan-hc/AM/blob/main/README.md#options" to see all the available options.

wget -q "https://raw.githubusercontent.com/ivan-hc/AM/main/APP-MANAGER" -O ./appman && chmod a+x ./appman

ZSHRC="${ZDOTDIR:-$HOME}/.zshrc"
BINDIR="${XDG_BIN_HOME:-$HOME/.local/bin}"
mkdir -p "$BINDIR"
if ! echo $PATH | grep "$BINDIR" >/dev/null 2>&1; then 
	if [ -e ~/.bashrc ] && ! grep 'PATH="$PATH:$BINDIR"' ~/.bashrc >/dev/null 2>&1; then
		printf '\n%s\n' 'BINDIR="${XDG_BIN_HOME:-$HOME/.local/bin}"' >> ~/.bashrc
		printf '\n%s\n' 'if ! echo $PATH | grep "$BINDIR" >/dev/null 2>&1; then' >> ~/.bashrc
		printf '	export PATH="$PATH:$BINDIR"\nfi\n' >> ~/.bashrc
	fi
	if [ -e "$ZSHRC" ] && ! grep 'PATH="$PATH:$BINDIR"' "$ZSHRC" >/dev/null 2>&1; then
		printf '\n%s\n' 'BINDIR="${XDG_BIN_HOME:-$HOME/.local/bin}"' >> "$ZSHRC"
		printf '\n%s\n' 'if ! echo $PATH | grep "$BINDIR" >/dev/null 2>&1; then' >> "$ZSHRC"
		printf '	export PATH="$PATH:$BINDIR"\nfi\n' >> "$ZSHRC"
	fi
fi
wget -q "https://raw.githubusercontent.com/ivan-hc/AM/$AM_BRANCH/APP-MANAGER" -O "$BINDIR"/appman && chmod a+x "$BINDIR"/appman

Since it is a portable script, you can simply remove it manually. If you used AM-INSTALLER, you simply need to remove the $HOME/.local/bin/appman script.

NOTE, it is recommended to remove apps first using the -R option, and then "AppMan", see also "How are apps installed", below.

"AppMan" is a portable script, you can use it anywhere you want and it will update itself on the spot. "AM" on the other hand has a fixed installation, and requires root privileges to be installed.

Another advantage is the fact that it can be downloaded by anyone, even non-privileged users. On the contrary "AM" belongs only to the person who installed it, having permissions to access directories in /opt.

"AppMan" can only install and manage local apps, while "AM" can manage both AppMan apps and install them locally or system-wide.

If you are a user who doesn't like using root privileges, just use "AppMan".

Locally installed apps can have a directory of your choice, depending on what you decided when you first started the appman command.

For example, let's say you want to create and use the /home/USER/Applicazioni directory, here is the structure of a locally embedded AppImage:

~/Applicazioni/$PROGRAM/
~/Applicazioni/$PROGRAM/$PROGRAM
~/Applicazioni/$PROGRAM/AM-updater
~/Applicazioni/$PROGRAM/remove
~/Applicazioni/$PROGRAM/icons/$ICON-NAME
~/.local/bin/$PROGRAM
~/.local/share/applications/$PROGRAM-AM.desktop

Unlike "AM" which needs to be placed in specific locations, "AppMan" is portable. The modules and directories will be placed in the directory you chose:

• the script "appman" is wherever you want (but it is recommended to install it in ~/.local/bin)
• the directory "/path/to/your/custom/directory/modules" (containing the .am modules for the non-core options)
• the configuration file "$HOME/.config/appman/appman-config" (the only fixed directory)

all processes will been executed in $HOME/.cache/appman, while application lists, keywords to use in bash/zsh completion and other files (for third party repos, betatesting, etcetera...) will be saved and updated in $HOME/.local/share/AM to be shared with "AM", if installed.

The guides for "AM" are also applicable to AppMan, just replace the command am with the command appman.

By clicking the links below, you will be redirected to the pages of the "AM" repository, at github.com/ivan-hc/AM

• Install applications
• Install only AppImages
  • Install and sandbox AppImages in one go
• Install AppImages not listed in this database but available in other github repos
• List the installed applications
• List and query all the applications available on the database
• Update all
• Backup and restore installed apps using snapshots
• Remove one or more applications
• Clone a set of programs installed from other AM and AppMan configurations
• Change the destination path of installed programs
• Convert Type2 AppImages requiring libfuse2 to New Generation AppImages
• Integrate local AppImages into the menu by dragging and dropping them
  • How to create a launcher for a local AppImage
  • How to remove the orphan launchers
  • AppImages from external media
  • Update scattered AppImages
• Sandbox an AppImage
  • How to enable a sandbox
  • How to disable a sandbox
  • Sandboxing example
  • About Aisap sandboxing
• How to update or remove apps manually
• Downgrade an installed app to a previous version
• How to use multiple versions of the same application
• Create and test your own installation script
  • Option Zero: "AppImages"
  • Option One: "build AppImages on-the-fly"
  • Option Two: "Archives and other programs"
  • Option Three: "Firefox profiles"
  • How an installation script works
  • How to test an installation script
  • How to submit a Pull Request
• Third-party databases for applications (NeoDB)
• BSD, freeBSD and derivative systems: configuration and troubleshooting

Instructions for Linux Distro Maintainers

Troubleshooting

• An application does not work, is old and unsupported
• Cannot download or update an application
• Cannot mount and run AppImages
• Failed to open squashfs image
• Spyware, malware and dangerous software
• Stop AppImage prompt to create its own launcher, desktop integration and doubled launchers
• The script points to "releases" instead of downloading the latest stable
• Ubuntu mess
• Wrong download link

• amcheck, checks the validity of scripts in this database and monitors the availability of AppImages
• am-extras, lists applications from third-party databases

• aisap and sas, sandboxing solutions for AppImages, see sandboxing options above
• appimagetool, get rid of libfuse2 from old AppImages (option nolibfuse) and create AppImages on the fly (see appimage-bulder-scripts)
• dbin, the easy to use/get, suckless software distribution system, used as OCI registry client to install packages from third-party databases

• Package Forge, Improving Package Management & Security for Linux systems
  • Dev, Package Forge's Official Developer Repos
  • Community, Package Forge's Community Repos, Projects & their Dependencies
• Portable Linux Apps, Census, cataloging and distribution of AppImages and portable apps for GNU/Linux

• AppImaGen, easily create AppImages from Ubuntu PPAs or Debian using pkg2appimage and appimagetool
• ArchImage, create AppImages for all distributions using Arch Linux packages. Powered by JuNest
• Firefox for Linux scripts, easily install the official releases of Firefox for Linux
• My AppImage packages the complete list of packages managed by me and available in this database
• Snap2AppImage, try to convert Snap packages to AppImages

© 2020-present Ivan Alessandro Sala aka 'Ivan-HC' - I'm here just for fun!