A minimal, focused Rust daemon that automatically integrates AppImages into the Linux desktop menu.

Existing solutions have issues for me:

Realistically, You probably want to use go-appimaged. It is a "big" project with a larger team and more features. I just want something that:

• notices I downloaded an AppImage,
• makes it executable,
• creates a .desktop file with the correct path and icon.
• bonus watches for moves and deletions to keep the desktop file updated.

appimage-auto does one thing well: watch directories and automatically integrate AppImages into your desktop menu.

You can just download a new AppImage and it will get integrated into your desktop automatically. If you delete the AppImage, it will be removed. Simple.

• Automatic Integration: Detects new AppImages and creates menu entries
• Magic Byte Validation: Verifies ELF + AppImage signatures (not just file extensions)
• Icon Extraction: Installs icons to the correct hicolor theme directories
• Move Tracking: Updates menu entries when AppImages are moved within watched directories
• Cleanup: Removes menu entries when AppImages are deleted
• Startup Scan: Integrates existing AppImages when the daemon starts
• Desktop Notifications: Optional notifications when apps are integrated or removed
• GUI Settings App: GTK4/Adwaita settings application for managing integrations and configuration
• Desktop Agnostic: Uses freedesktop.org standards (works with GNOME, KDE, XFCE, etc.)

Everything installs to your user home directory — no root access or system-level changes required. Even the background daemon runs as a systemd user service.

1. Download the latest appimage-auto-*-x86_64-linux.zip from GitHub Releases
2. Extract and run the installer:

unzip appimage-auto-*-x86_64-linux.zip
cd appimage-auto
./install.sh

That's it. The installer:

• Places binaries in ~/.local/bin/
• Installs and starts a systemd user service
• Installs the GUI desktop entry (if included in the bundle)
• Creates a default config at ~/.config/appimage-auto/config.toml (preserves any existing config)
• Warns you if ~/.local/bin is not in your $PATH

systemctl --user status appimage-auto

The bundle includes an uninstall script:

cd appimage-auto
./uninstall.sh

You'll be asked whether to also remove configuration and state data. For non-interactive use:

./uninstall.sh --remove-data   # remove everything
./uninstall.sh --keep-data     # keep config and state

All files live under your home directory:

Requires Rust 1.70+ and Linux.

git clone https://github.com/youruser/appimage-auto
cd appimage-auto
cargo build --release

For the GUI, you also need GTK4 and libadwaita development libraries:

# Fedora
sudo dnf install gtk4-devel libadwaita-devel

# Ubuntu/Debian
sudo apt install libgtk-4-dev libadwaita-1-dev

# Arch
sudo pacman -S gtk4 libadwaita

cargo build --release --features gui

To build a release bundle zip:

just bundle

# Run daemon in foreground (for testing)
appimage-auto daemon

# One-shot scan (integrate existing, cleanup orphaned, exit)
appimage-auto scan

# Show status and statistics
appimage-auto status

# List all integrated AppImages
appimage-auto list

# Manually integrate a specific AppImage
appimage-auto integrate ~/Downloads/SomeApp.AppImage

# Remove integration for an AppImage
appimage-auto remove ~/Downloads/SomeApp.AppImage

# View current configuration
appimage-auto config show

# Add a watch directory
appimage-auto config add-watch ~/Apps

# Remove a watch directory
appimage-auto config remove-watch ~/Apps

# Verbose output (-v, -vv, -vvv)
appimage-auto -vv daemon

Launch from your application menu or run:

appimage-auto-gui

The GUI provides:

• Overview: Daemon status, list of integrated apps and watched directories
• Apps: Manage integrated AppImages — remove integrations or open file locations
• Settings: Add/remove watch directories, configure notifications, adjust daemon settings, enable/disable autostart

Configuration is stored at ~/.config/appimage-auto/config.toml:

[watch]
# Directories to monitor for AppImages
directories = [
    "~/Downloads",
    "~/Applications",
    "~/.local/bin",
]

# File patterns (in addition to magic byte detection)
patterns = ["*.AppImage", "*.appimage"]

# Debounce delay in milliseconds
debounce_ms = 1000

[integration]
# Where to install .desktop files
desktop_dir = "~/.local/share/applications"

# Where to install icons
icon_dir = "~/.local/share/icons/hicolor"

# Run update-desktop-database after changes
update_database = true

# Scan for existing AppImages on startup
scan_on_startup = true

[logging]
level = "info"  # trace, debug, info, warn, error

[notifications]
# Enable desktop notifications
enabled = true

# Notify when an AppImage is integrated
on_integrate = true

# Notify when an AppImage is removed
on_unintegrate = true

# Start/stop/restart
systemctl --user start appimage-auto
systemctl --user stop appimage-auto
systemctl --user restart appimage-auto

# View logs
journalctl --user -u appimage-auto -f

# Disable autostart
systemctl --user disable appimage-auto

1. Monitors configured directories using inotify
2. When a file appears, checks for AppImage magic bytes:
   • ELF header: 0x7F 'E' 'L' 'F'
   • AppImage signature at offset 8: 'A' 'I' 0x01 (Type 1) or 'A' 'I' 0x02 (Type 2)
3. Validates completeness by checking the SquashFS superblock before integrating

1. Makes the AppImage executable (chmod +x)
2. Extracts metadata using --appimage-extract
3. Parses the embedded .desktop file
4. Modifies Exec= to point to the actual AppImage path
5. Adds tracking identifier (X-AppImage-Identifier)
6. Installs icons to ~/.local/share/icons/hicolor/<size>/apps/
7. Writes .desktop file to ~/.local/share/applications/
8. Runs update-desktop-database

1. Check if it's a valid AppImage: appimage-auto integrate /path/to/app.AppImage -v
2. Verify the AppImage has an embedded .desktop file
3. Check logs: journalctl --user -u appimage-auto

The daemon only tracks moves within watched directories. Moving an AppImage to an unwatched location will remove its integration.

Some AppImages don't include icons. The integration will still work, but without a custom icon.

Releases are automated via GitHub Actions. Pushing a version tag triggers a build and creates a GitHub Release with the bundled zip.

To create a release using cargo-release:

# Install cargo-release (one-time)
cargo install cargo-release

# Dry run (no changes made)
cargo release patch

# Create a patch release (0.2.1 → 0.2.2)
cargo release patch --execute

# Create a minor release (0.2.1 → 0.3.0)
cargo release minor --execute

# Create a major release (0.2.1 → 1.0.0)
cargo release major --execute

This bumps the version in Cargo.toml, commits, tags, and pushes — triggering the release workflow.

MIT