A Rust implementation of AppImageUpdate - a tool for updating AppImages using efficient delta updates.

• Delta Updates - Only download the changed portions of the AppImage, saving bandwidth and time
• Parallel Updates - Update multiple AppImages concurrently with per-URL deduplication
• Decentralized - No central repository required; updates come directly from the source
• Directory Scanning - Pass a directory to update all AppImages inside
• Progress Bars - Real-time progress during downloads with per-file bars
• Checksum Verification - SHA1 verification ensures downloaded files are valid
• Permission Preservation - Maintains executable permissions from the original AppImage
• Skip Unnecessary Updates - Automatically skips update if the target file already exists with the correct checksum
• In-Place Updates - Updates to same filename preserve old version as .old backup

git clone https://github.com/pkgforge-dev/appimageupdate.git
cd appimageupdate
cargo install --path .

appimageupdate ./myapp.AppImage

appimageupdate ./app1.AppImage ./app2.AppImage ./app3.AppImage

AppImages are updated concurrently. When multiple AppImages share the same update source, the download happens only once and the result is copied to the rest.

Control parallelism with -J:

appimageupdate -J 4 ~/Applications/

Use 0 (default) to auto-detect based on CPU count.

appimageupdate ~/Applications/

appimageupdate -j ./myapp.AppImage

Check multiple AppImages in parallel:

appimageupdate -j ~/Applications/

Exit code 1 if any update available, 0 if all up to date.

appimageupdate -d ./myapp.AppImage

appimageupdate [OPTIONS] [APPIMAGE]...

Arguments:
  [APPIMAGE]...           Path(s) to AppImage(s) or directories to update

Options:
  -O, --overwrite         Overwrite existing target file
  -r, --remove-old        Remove old AppImage after successful update
  -u, --update-info <INFO> Override update information in the AppImage
      --output-dir <DIR>  Output directory for updated AppImages
  -d, --describe          Parse and describe AppImage and its update information
  -j, --check-for-update  Check for update (exit 1 if any available, 0 if not)
  -J, --jobs <N>          Number of parallel jobs (default: 0 = auto-detect)
      --github-api-proxy <URL>  GitHub API proxy URL [env: GITHUB_API_PROXY]
                            (supports comma-separated list for fallback)
  -h, --help              Print help
  -V, --version           Print version

1. Reads Update Information - Extracts embedded update info from the AppImage's .upd-info ELF section
2. Fetches Zsync Metadata - Downloads the .zsync control file which contains block checksums and file metadata
3. Calculates Delta - Compares local file blocks against remote blocks using rolling checksums
4. Downloads Only Changes - Fetches only the blocks that differ from the local copy
5. Assembles & Verifies - Reconstructs the file and verifies SHA1 checksum

Create a config file at ~/.config/appimageupdate/config.toml:

# GitHub API proxy (supports single or multiple for fallback)
github_api_proxy = "https://ghproxy.net"
# Or multiple proxies:
# github_api_proxy = ["https://ghproxy.net", "https://mirror.example.com"]

# Remove old AppImage after successful update
remove_old = true

# Output directory for updated AppImages (supports shell expansion)
output_dir = "~/Applications"

Priority: CLI args > Environment variables > Config file

• zsync|<url> - Direct zsync URL
• gh-releases-zsync|<user>|<repo>|<tag>|<filename> - GitHub releases with glob pattern matching

This is a Rust rewrite of the upstream AppImageUpdate (C++/Qt).

Advantages:

• Single static binary with no runtime dependencies
• Over 10x smaller
• Cleaner, more maintainable codebase
• URL caching to avoid redundant API calls
• Proxy support
• Better error messages

Differences:

• No GPG signature verification (not implemented)
• No pling integration (not implemented)
• No GUI (not implemented)

use appimageupdate::{Updater, Error};

fn main() -> Result<(), Error> {
    let updater = Updater::new("./myapp.AppImage")?
        .progress_callback(|done, total| {
            if total > 0 {
                eprintln!("Progress: {}/{}", done, total);
            }
        });

    if updater.check_for_update()? {
        let (path, stats) = updater.perform_update()?;
        println!("Updated to: {}", path.display());
        println!("Saved {}% bandwidth", stats.saved_percentage());
    } else {
        println!("Already up to date!");
    }

    Ok(())
}