r/AppImage • u/gneuromante • 1d ago
[ANN] alr2appimage v1.1: now with Debian and RPM packages support
Tool for generating AppImages from an Ada Alire application.
r/AppImage • u/gneuromante • 1d ago
Tool for generating AppImages from an Ada Alire application.
r/AppImage • u/birazzzzz • 15d ago
FynePDF is a desktop PDF editor, and the Linux version ships as an AppImage. I make it, so this is the official build.
- File: FynePDF-1.0.0-x86_64.AppImage, about 157 MB (it bundles Qt, Qt WebEngine and the OCR runtime)
- x86-64 only. Tested on Ubuntu 22.04 and 24.04, Omarchy, Fedora 44 and Debian 12; it should run on most distros from about 2022 on, on Wayland or X11
- GPG-signed. The key and the steps to check it are at https://fynepdf.com/download/linux
- Settings has "Add to apps menu", which writes the .desktop entry and icons for you and follows the file if you move it
- Updates: the app shows a card when a new version is out, and you swap the file. No AppImageUpdate/zsync yet
It's closed source and needs a free account. You sign in once online, and the PDF tools work offline after that. There are paid plans for the bigger features.
Download: https://downloads.fynepdf.com/linux/FynePDF-1.0.0-x86_64.AppImage
Reports of how it runs on your distro are very welcome.
r/AppImage • u/CompanyEuphoric7400 • Oct 22 '26
Despertador is a desktop alarm clock for Linux, and the reason I'm posting it here is that shipping it as one file was a design constraint from day one, not an afterthought.
What's inside: alarms with weekday repeat, labels and snooze; world clock (offline, via zoneinfo); stopwatch and countdown. Python + Tkinter only, so there is no requirements.txt to rot.
Distribution details that may be useful to other AppImage maintainers:
Single ~15 MB AppImage, no Python on the target machine. The interpreter and the Tcl/Tk libs are bundled, including the Xft/font bits, which is usually where Tkinter bundling quietly breaks.
Sound is a fallback chain, not one call: paplay -> aplay -> ffplay -> canberra-gtk-play -> terminal bell, plus notify-send. No single player binary exists everywhere, so assuming one is how you ship a silent alarm.
libfuse2: yes, the same old story. On distros that dropped FUSE 2 the AppImage won't start until libfuse2 is installed, or you run it with APPIMAGE_EXTRACT_AND_RUN=1. It's documented in the README rather than left as a mystery.
No systemd unit is shipped. The app stays open, or you call the CLI (run / inhibit) from your own autostart entry.
The honest limitation: alarms fire while the app is running. Close it and nothing rings.
Repo (MIT): https://github.com/glearflame/despertador Release: https://github.com/glearflame/despertador/releases/latest
Critique on the bundling from people who package AppImages is very welcome.
r/AppImage • u/am-ivan • Oct 07 '26
Main page: https://portable-linux-apps.github.io
AppImages list: https://portable-linux-apps.github.io/en/appimages.html
"AM" application manager: https://github.com/ivan-hc/AM
Thanks to research conducted by Probonopd for his catalog and the contribution of the Pkgforge-dev team, we have managed (in just over 10 days) to increase the number of AppImage packages from the roughly 3,000 collected over the five years since the "AM" package manager was created to over 7,000 unique entries. We are also on the verge of reaching the 8,000 AppImage packages in the coming days.
This achievement was made possible in part by improvements to the `template.am` module (the "AM" `-t` option). It can now detect most descriptions (highlighted in green) and identify download URLs (highlighted in yellow) within the GitHub repositories, all of which are manually vetted by me and my closest collaborators (humans, not AI).
As a reminder, "AM" acts as a bridge between the program's developer or maintainer and you, the end user. You can consult the web catalog mentioned above to view sources and contact package owners to suggest improvements. "AM" itself is not responsible for the malfunctioning of individual applications. However, you can open an issue or a pull request to report or remove any malicious apps at the following address:
Our current workflows (see "amcheck") can verify whether listed applications still exist and if the installation processes complete successfully. If an installation script fails, we are ready to investigate and resolve the issue; in extreme cases, we may remove the app from the list to ensure the reliability of the applications available to all users.
I look forward to your feedback, and in the meantime, enjoy the most comprehensive list of AppImage packages currently available:
https://portable-linux-apps.github.io
NOTE: This catalog is open source. You can contribute by editing the pages, adding missing information, or improving the database. You are all invited to participate!
r/AppImage • u/brunomnsilva • Sep 29 '26
r/AppImage • u/Odd-Side-3444 • Sep 28 '26
r/AppImage • u/TrainFun9639 • Sep 24 '26
AM 10.6 is released.
Some highlights:
One click install: Install AppImages directly by clicking the install button on the Portable Linux Apps Website
Parallel install: Install multiple apps simultaneously.
Redesign of website: Portable Linux app website has been redesigned, with an install button for each app.
3000+ AppImages: The repository now reached 3000+ appimages!
And many more...
Checkout https://portable-linux-apps.github.io/
AM is a command-line application manager for Linux that makes it easy to install, update, remove, and manage AppImages and other portable applications. It integrates apps into the system or installs them locally, provides a searchable app database, and supports bulk updates and AppImage sandboxing.
r/AppImage • u/PrestonBannister • Sep 24 '26
Wanted to make use of AppImage applications simpler, so wrote gnome-appimage-integration.
Reduces an AppImage install (er, integration) to three clicks.
Github: gnome-appimage-integration
Weblog: Better integration of AppImage
Tried to handle all the usual edge cases and XDG / FreeDesktop conventions.
Right-click context menu for downloaded file:

Main AppImage Activator window:

Status after Integrate:

Right-click context menu for application:

Downloaded AppImage is moved into $HOME/Applications/
so no manual cleanup needed.
r/AppImage • u/parallel-minds • Sep 17 '26
r/AppImage • u/theWonderBit • Aug 26 '26
Hi everyone,
A while back, I ran into an issue that I’m sure many of you have experienced: Heroic Game Launcher was underperforming in Flatpak. The lag and stuttering were noticeable, and while switching to .deb or .appimage formats solved the performance problems, it introduced another issue—system pollution from installing dependencies like Gamescope or Mangohud. I had grown accustomed to Flatpak’s clean sandboxing, and I didn’t want to give that up.
That’s when I discovered Anylinux-AppImages, along with tools like AppManager, Sharun, Uruntime, and Lib4bin. I dove deep into how these components work together, studied their interactions, and after many trials (and a few headaches), I decided to build my own AppImage for Heroic. Instead of sticking to the traditional upstream packaging method, I symbolically broke away from it to approach the project with more flexibility. The result? An AppImage that bundles all the key components, allowing Heroic to work out of the box—no external dependencies, no system clutter.
Today, I have functional AppImages for Heroic, Vivaldi, Spotify, Waterfox, and Steam (the latter is still a work in progress). I also plan to package QT and GTK applications to better understand their quirks. All of these AppImages are built from official sources and follow the standards of Anylinux-AppImages, Sharun, Uruntime, and Lib4bin, so they’re completely safe and reliable.
But this goes beyond just my personal experience. I see Anylinux-AppImages as a real opportunity to offer a solid alternative to Flatpak and Snap. While those formats rely on centralization, Anylinux-AppImages puts control back in the hands of developers, avoiding the fragmentation that comes with different Linux distributions. Plus, projects like PPSSPP, AppManager, and Citron Neo already offer AppImages as an option, proving that it’s a viable solution.
However, there’s a catch: we’re all packaging unofficially. Me, pkgforge-dev, ivan-hc, and others are doing great work, but if we don’t join forces, we might end up repeating the same fragmentation we’re trying to avoid. That’s why I propose:
Creating a common framework to standardize the use and build of Anylinux-AppImages.
Promoting this format so more projects adopt it, even as an official option.
Working toward enterprise adoption, so it can compete on equal footing with Flatpak and Snap.
Could Anylinux-AppImages one day become a Unix standard for Linux and FreeBSD? I believe it has the potential, but I need your feedback. Are you interested in this project? Do you know of similar initiatives? How can we push this forward together?
If you’d like to try my AppImages, they’re available in my GitLab repository: jesusrosdiaz/appimages.
Thanks for your time and input—I’m looking forward to hearing your thoughts!
r/AppImage • u/ehraja • Jun 30 '26
r/AppImage • u/Global_Bag1657 • May 13 '26
Small OmniPkg update after feedback:
OmniPkg now uses PackageKit for supported distro package management, currently APT, DNF/dnf5 and Zypper/libzypp.
It keeps separate adapters for sources PackageKit does not cover well: AUR helpers, Flatpak, Snap, Homebrew, npm, pipx, AppImages and archives.
Update: OmniPkg now also includes a Qt frontend. It is no longer GTK-only. The app has a shared package-management backend and separate GTK/Qt frontends, with automatic frontend selection.
Hi,
I’ve published OmniPkg, a native GTK4 software manager that includes support for manually installed AppImages and archive-based applications.
The project is broader than AppImage only: it also supports APT, DNF/dnf5, Zypper, Pacman, AUR via yay/paru, APK, XBPS, eopkg, Flatpak, Snap, Homebrew, npm and pipx.
But one of the use cases I care about is making manually downloaded AppImages less messy:
- add/manage AppImages
- create desktop launchers
- show them alongside other installed applications
- keep manual installs more visible instead of forgetting random files in Downloads
OmniPkg does not replace AppImage tooling or system package managers. It tries to provide one desktop interface for users who mix several software sources.
I’d be especially interested in feedback from AppImage users:
- What metadata should OmniPkg detect?
- How should updates be handled?
- What should desktop integration do or avoid?
- What would make AppImage management actually pleasant?
GitHub:
r/AppImage • u/david455678 • May 07 '26
I have a question regarding an AppImage that can only be opened by using --no-sandbox, which I don't want to use. Are there any ways to prevent that. It should be as easy as possible
r/AppImage • u/suoko • Apr 29 '26
Creating an AppImage for a Java application is straightforward. Since you're using an **Early Access (EA)** build of OpenJDK 25, it's best to bundle the JRE/JDK directly inside the AppImage to avoid system dependency issues.
Here's a complete, step-by-step guide:
### 🔹 Prerequisites
- Linux x86_64 system (AppImage architecture must match target)
- `curl`, `tar`, `chmod`
- `appimagetool` (official AppImage generator)
- Your `.jar` file
- A 256×256 PNG icon (optional but recommended)
---
### 📦 Step 1: Download OpenJDK 25.0.3-ea
EA builds aren't in distro repos. Download the official tarball from JDK Early Access:
Go to: https://jdk.java.net/25/
Download the `Linux/x64` `.tar.gz` archive for the EA build you need.
Example (replace with the actual link from the site):
```bash
wget https://download.java.net/java/early_access/jdk25/3/GPL/openjdk-25-ea+3_linux-x64_bin.tar.gz
```
---
### 📁 Step 2: Create the AppDir Structure
AppImage expects a specific directory layout:
```bash
mkdir MyApp.AppDir
cd MyApp.AppDir
mkdir -p usr/lib usr/bin
```
---
### ☕ Step 3: Bundle OpenJDK & Your JAR
```bash
# Extract JDK
tar -xzf /path/to/openjdk-25-ea+*_linux-x64_bin.tar.gz -C usr/lib/
# Rename for simplicity
mv usr/lib/jdk-25* usr/lib/jdk25-ea
# Copy your JAR
cp /path/to/your-app.jar usr/lib/your-app.jar
```
---
### 📜 Step 4: Create `AppRun`, `.desktop`, and Icon
#### `AppRun` (entrypoint)
```bash
cat > AppRun << 'EOF'
#!/bin/bash
set -e
APPDIR="$(cd "$(dirname "$0")" && pwd)"
JAVA_HOME="$APPDIR/usr/lib/jdk25-ea"
export JAVA_HOME
export PATH="$JAVA_HOME/bin:$PATH"
exec "$JAVA_HOME/bin/java" -jar "$APPDIR/usr/lib/your-app.jar" "$@"
EOF
chmod +x AppRun
```
#### `.desktop` file
```bash
cat > your-app.desktop << 'EOF'
[Desktop Entry]
Name=Your App
Exec=AppRun
Icon=your-app
Type=Application
Categories=Utility;
Terminal=false
EOF
```
> 🔍 Replace `Your App` and `your-app` with your actual app name (no spaces in `Icon=` or filename).
#### Icon
Place a 256×256 PNG named `your-app.png` in the root of `MyApp.AppDir/`.
---
### 🛠️ Step 5: Generate the AppImage
Download `appimagetool` (if not installed):
```bash
curl -L https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -o appimagetool
chmod +x appimagetool
```
Build the AppImage:
```bash
./appimagetool MyApp.AppDir YourApp-x86_64.AppImage
```
This creates `YourApp-x86_64.AppImage` in your current directory.
---
### ▶️ Step 6: Test & Distribute
```bash
chmod +x YourApp-x86_64.AppImage
./YourApp-x86_64.AppImage
```
If it runs successfully, you can distribute the `.AppImage` file directly. Users just need to `chmod +x` and run it.
---
### 💡 Pro Tips & Optimizations
| Topic | Recommendation |
|-------|----------------|
| **Reduce Size** | Use `jlink` (included in JDK 25) to create a minimal runtime image with only required modules. Replace `usr/lib/jdk25-ea` with the `jlink` output. |
| **GUI Dependencies** | AppImages don't bundle host GUI libs. Ensure users have basic X11/Wayland, GTK, or JavaFX dependencies (usually preinstalled on desktop Linux). |
| **FUSE Note** | On newer Ubuntu/Debian, you may need `libfuse2` or run with `--appimage-extract-and-run`. |
| **EA Caveats** | EA builds may lack stability, missing modules, or have changed flags. Test thoroughly before distribution. |
| **Signing** (optional) | Add `--sign` to `appimagetool` if you want cryptographic verification. |
---
### 🐛 Troubleshooting
- `Error: Unable to initialize main class...` → Verify JAR path in `AppRun` and that the JAR has a valid `Main-Class` manifest entry.
- `libfuse.so.2: cannot open shared object file` → Install `libfuse2` or extract & run: `./YourApp.AppImage --appimage-extract && ./squashfs-root/AppRun`
- `Module java.desktop not found` → If using `jlink`, ensure `java.desktop` is included.
r/AppImage • u/vidya_geezer • Apr 14 '26
Hi All,
I've been using AM for all of my Appimage needs and would like to know if anyone is experiencing this issue. It seems to mostly affect media applications like Gimp, Inkscape, etc.
I install the app and when going to open files I don't have access to my external storage mounts. I have a NAS and RAID mounted on /vol1 and /vol2. Those mount points are not there and the disks are not listed under /media/user, /run/media/user nor can I access them via /dev/disk/etc. Essentially I have no access whatsoever.
Unfortunately what I usually do is nuke them from my system, then try nala and at the very lost option is flatpak which I try to avoid at all costs.
Anyone know of a workaround?
r/AppImage • u/stonerl • Apr 10 '26
Hi everyone,
I recently created an app to sync Game Boy ROMs with CrankBoy, an emulator for the Playdate.
My goal was to have a cross-platform app that runs on Windows, macOS and Linux. So I chose Python and PyQt6. While creating packages for Windows and macOS was fairly straightforward, having a self-contained app for Linux that runs on all distributions wasn’t.
I really thought Flatpak would be the way to go, but the PyQt build tools make it so easy to create a universal application, that I ditched the idea of creating a Flatpak.
I really did not think highly of AppImages when I started with the project, but I’m convinced now. AppImages are by far the easiest way to create and distribute Apps on Linux.
r/AppImage • u/ehraja • Apr 05 '26
r/AppImage • u/topchetoeuwastaken • Apr 05 '26
Since AppImageLauncher has a hard dependency on systemd, I wrote this small bash script for all of us folks who don't run systemd.
It does one thing and one thing only - generates .desktop files for all appimage files in a given folder.
r/AppImage • u/ehraja • Apr 04 '26
r/AppImage • u/ehraja • Apr 04 '26
r/AppImage • u/ehraja • Apr 04 '26
r/AppImage • u/am-ivan • Mar 25 '26
Hi folks, I'm the developer of AM package manager, Archimage and AppImaGen, and the maintainer of about 100 unofficial AppImage packages.
Based on my guide on how to convert simple portable programs to AppImage, here, today I created a new tool:
https://github.com/ivan-hc/portable2appimage
This isn't a complex package tool. All you have to do is run it next to an executable binary or an archive containing one (specifying the binary name), and the script will convert it into an AppImage.
can also create them with support for delta updates, if you give it the right instructions.
More details and video examples are available in the repository.
I hope you enjoy it.