Ein **AppImage** stellt eine Linux-Anwendung mit vielen ihrer benötigten Bestandteile in einer einzelnen Datei bereit. Du lädst die Datei herunter, machst sie ausführbar und startest das Programm – normalerweise ohne klassische Installation über APT, DNF oder Zypper.
Das ist praktisch, wenn du eine Anwendung direkt vom Anbieter beziehen oder unterschiedliche Versionen getrennt aufbewahren möchtest. Allerdings übernimmt die normale Paketverwaltung deiner Distribution damit nicht automatisch die Aktualisierung dieser Anwendung.
Was ist ein AppImage?
---------------------
Ein AppImage ist eine ausführbare Datei, die eine Anwendung und viele ihrer benötigten Komponenten enthält. Dazu können Bibliotheken, Symbole und weitere Programmdateien gehören.
Ein Dateiname könnte beispielsweise so aussehen:
```
Beispielprogramm-1.2-x86_64.AppImage
```
Die Bestandteile des Namens geben häufig Hinweise auf die Anwendung, ihre Version und die vorgesehene Rechnerarchitektur. Die genaue Benennung legt der Anbieter fest.
Das Grundprinzip lautet: Eine Anwendung wird als eine Datei verteilt. Du musst ihre Bestandteile nicht einzeln auf dem System installieren.
### Bedeutet das vollständige Unabhängigkeit vom System?
Nein. Ein AppImage verwendet weiterhin bestimmte Bestandteile des Linux-Systems, beispielsweise grundlegende Bibliotheken oder Komponenten der Grafikumgebung.
Der Anbieter muss deshalb entscheiden, welche Systeme er unterstützt und welche zusätzlichen Komponenten er mitliefert. Ein AppImage funktioniert nicht automatisch auf jeder Distribution oder jeder beliebig alten Linux-Version.
Ein AppImage sicher herunterladen
---------------------------------
Beziehe AppImages möglichst über die offizielle Website der Anwendung oder eine dort ausdrücklich genannte Veröffentlichungsseite.
Achte vor dem Download auf:
- die Herkunft der Datei,
- die unterstützten Linux-Systeme,
- die passende Rechnerarchitektur,
- den Versionsstand und die verfügbaren Aktualisierungen.
Ein AppImage für `x86_64` ist beispielsweise für 64-Bit-x86-Systeme vorgesehen. Eine ARM-Ausgabe ist damit nicht einfach austauschbar.
Die Dateiendung `.AppImage` ist kein Sicherheitsnachweis. Das Format beschreibt, wie die Anwendung verteilt wird – nicht, ob ihr Inhalt vertrauenswürdig ist.
Ein AppImage über den Dateimanager starten
------------------------------------------
Bei vielen Desktop-Umgebungen lässt sich ein AppImage ohne Terminal vorbereiten:
1. Öffne den Ordner mit der heruntergeladenen Datei.
2. Klicke mit der rechten Maustaste auf das AppImage.
3. Öffne die Eigenschaften.
4. Suche die Einstellungen für Berechtigungen oder Zugriffsrechte.
5. Erlaube das Ausführen der Datei als Programm.
6. Starte die Datei anschließend per Doppelklick.
Die genaue Bezeichnung der Einstellung hängt vom Dateimanager ab. Sie kann beispielsweise „Datei als Programm ausführen“ oder „Ausführbar“ heißen.
Ein AppImage im Terminal starten
--------------------------------
Im folgenden Beispiel heißt die heruntergeladene Datei `Beispielprogramm.AppImage`. Ersetze diesen Namen durch den tatsächlichen Dateinamen.
### In den passenden Ordner wechseln
Wenn dein Downloadordner `Downloads` heißt:
```
cd ~/Downloads
```
### Die Datei ausführbar machen
```
chmod u+x Beispielprogramm.AppImage
```
Die Bestandteile bedeuten:
| Bestandteil | Erklärung |
|---|---|
| `chmod` | Ändert die Zugriffsrechte einer Datei. |
| `u` | Bezieht sich auf den Eigentümer der Datei. |
| `+x` | Fügt das Recht hinzu, die Datei auszuführen. |
Dadurch wird die Anwendung noch nicht gestartet. Du erlaubst zunächst nur ihre Ausführung.
### Die Anwendung starten
```
./Beispielprogramm.AppImage
```
`./` bedeutet: Starte die Datei aus dem aktuellen Verzeichnis.
Für das normale Starten eines AppImages benötigst du kein `sudo`. Die Anwendung soll mit deinen Benutzerrechten laufen, nicht mit administrativen Rechten. Das grundlegende Vorgehen „ausführbar machen und starten“ entspricht der offiziellen AppImage-Anleitung.
AppImages übersichtlich aufbewahren
-----------------------------------
Für dauerhaft verwendete Anwendungen ist ein eigener Ordner übersichtlicher als der Downloadordner.
Beispielsweise:
```
mkdir -p ~/Applications
mv ~/Downloads/Beispielprogramm.AppImage ~/Applications/
```
Anschließend startest du die Anwendung mit:
```
~/Applications/Beispielprogramm.AppImage
```
`Applications` ist dabei eine mögliche Ablage, keine zwingende Voraussetzung des Formats. Auch Werkzeuge zur Desktop-Einbindung verwenden einen solchen Ordner.
Ein fester Speicherort ist besonders hilfreich, wenn später ein Menüeintrag auf die Datei verweist.
Die Anwendung ins Startmenü aufnehmen
-------------------------------------
Ein AppImage erscheint nicht allein deshalb automatisch im Anwendungsmenü, weil du es heruntergeladen hast.
Das Hinzufügen von Menüeintrag und Symbol wird als Desktop-Integration bezeichnet. Dafür gibt es unterschiedliche Möglichkeiten:
- Die Anwendung bringt eine eigene Integration mit.
- Ein zusätzliches Verwaltungswerkzeug übernimmt die Einbindung.
- Ein passender Desktop-Eintrag wird manuell angelegt.
Die AppImage-Dokumentation nennt beispielsweise [AppImageLauncher](https://appimagelauncher.org/) als ergänzendes Werkzeug zur Integration und Verwaltung. Ob ein solches Werkzeug für deine Distribution und Desktop-Umgebung geeignet ist, solltest du vor der Einrichtung prüfen.
> Wichtig: Ein Menüeintrag ist eine Verknüpfung zur Anwendung. Verschiebst oder löschst du die AppImage-Datei später, kann der Eintrag ins Leere zeigen.
AppImages aktualisieren
-----------------------
AppImages besitzen keinen einheitlich vorgeschriebenen Aktualisierungsweg. Welche Möglichkeiten zur Verfügung stehen, entscheidet der Anbieter.
Typische Varianten sind:
| Möglichkeit | Wie sie funktioniert |
|---|---|
| Eingebaute Update-Funktion | Die Anwendung bietet selbst eine Aktualisierung an. |
| Zusätzliches Update-Werkzeug | Ein Werkzeug wie [AppImageUpdate](https://appimage.github.io/AppImageUpdate/) verarbeitet passende Update-Informationen. |
| Manueller Download | Du lädst die neue Version herunter und ersetzt die bisher verwendete Datei. |
AppImageUpdate funktioniert nicht automatisch mit jeder AppImage-Datei. Dafür müssen geeignete Update-Informationen vorhanden sein. Manche Anbieter verwenden stattdessen ein eigenes Verfahren.
### Eine neue Version manuell übernehmen
Ein übersichtliches Vorgehen ist:
1. Die Anwendung schließen.
2. Die neue Version aus derselben vertrauenswürdigen Quelle herunterladen.
3. Die neue Datei ausführbar machen.
4. Die neue Version starten und prüfen.
5. Anschließend die nicht mehr benötigte alte Datei entfernen.
6. Gegebenenfalls den Menüeintrag anpassen.
Mehrere Versionen können als getrennte Dateien aufbewahrt werden. Das bedeutet allerdings nicht automatisch, dass auch ihre Einstellungen voneinander getrennt sind.
Wo speichert ein AppImage seine Einstellungen?
----------------------------------------------
„Eine Anwendung in einer Datei“ bedeutet nicht, dass beim Ausführen keinerlei weitere Dateien entstehen.
Die enthaltene Anwendung speichert Einstellungen, Cache und andere Daten normalerweise dort, wo sie diese auch bei einer anderen Installationsform ablegen würde – häufig innerhalb deines persönlichen Verzeichnisses.
Die AppImage-Datei und die persönlichen Anwendungsdaten sind daher normalerweise getrennt. Löschst du nur das AppImage, bleiben Einstellungen und gespeicherte Daten möglicherweise erhalten.
### Optional: Daten neben dem AppImage speichern
Geeignete AppImages mit einer entsprechend unterstützenden AppImageKit-Laufzeit besitzen einen portablen Modus. Dafür legst du neben der Datei ein speziell benanntes Verzeichnis an.
Beispiel:
```
Beispielprogramm.AppImage
Beispielprogramm.AppImage.home/
```
Anlegen kannst du es im Ordner des AppImages mit:
```
mkdir Beispielprogramm.AppImage.home
```
Die unterstützende Laufzeit setzt dann das persönliche Verzeichnis der gestarteten Anwendung auf diesen Ordner.
Alternativ gibt es:
```
Beispielprogramm.AppImage.config/
```
Damit wird das Konfigurationsverzeichnis über `XDG_CONFIG_HOME` umgeleitet. Der Name des Verzeichnisses muss zum Namen der AppImage-Datei passen.
Der portable Modus ist keine Sandbox und keine Garantie, dass eine Anwendung ausschließlich in diesen Ordner schreibt.
Ein AppImage entfernen
----------------------
Wenn du eine Anwendung nicht mehr benötigst:
1. Beende die Anwendung.
2. Lösche die zugehörige AppImage-Datei.
3. Entferne gegebenenfalls den Menüeintrag.
4. Entscheide getrennt, ob du auch die persönlichen Einstellungen und Daten löschen möchtest.
Eine klassische Deinstallation über APT, DNF oder Zypper ist für eine manuell heruntergeladene AppImage-Datei nicht erforderlich. Bei Verwendung eines Verwaltungswerkzeugs kannst du dessen Entfernungsfunktion nutzen.
Lösche persönliche Daten nicht allein aufgrund eines ähnlich klingenden Ordnernamens. Prüfe zuerst, welche Daten dort liegen und ob sie noch benötigt werden. Die Speicherorte hängen von der Anwendung ab.
Wenn ein AppImage nicht startet
-------------------------------
Starte die Datei zunächst im Terminal:
```
./Beispielprogramm.AppImage
```
So kannst du Fehlermeldungen lesen, die bei einem Doppelklick möglicherweise nicht sichtbar bleiben.
### Die Datei ist nicht ausführbar
Prüfe zunächst, ob das Ausführungsrecht gesetzt wurde:
```
chmod u+x Beispielprogramm.AppImage
```
Versuche anschließend erneut zu starten. Das Ausführungsrecht gehört zu den grundlegenden Voraussetzungen für den direkten Start.
### Es erscheint ein FUSE-Fehler
Viele verbreitete AppImages verwenden **FUSE**, um ihren enthaltenen Dateisysteminhalt beim Start zugänglich zu machen. Fehlt die benötigte Unterstützung, kann die Anwendung deshalb scheitern.
Welche Pakete dafür erforderlich sind, hängt von der Distribution, ihrer Version und der verwendeten AppImage-Laufzeit ab. Übernimm deshalb nicht ungeprüft Installationsbefehle für ein anderes System.
Bei unterstützenden AppImages kannst du als Alternative versuchen:
```
./Beispielprogramm.AppImage --appimage-extract-and-run
```
Dabei wird der Inhalt vorübergehend entpackt, ausgeführt und anschließend wieder aufgeräumt. Das kann den Start ohne die sonst benötigte FUSE-Einbindung ermöglichen. Der Parameter wird nicht von jeder älteren AppImage-Laufzeit unterstützt.
### Eine benötigte Systembibliothek ist zu alt
Eine Fehlermeldung wie:
```
GLIBC_2.xx not found
```
kann darauf hinweisen, dass das AppImage eine neuere Systemumgebung voraussetzt.
Die Lösung besteht dann nicht darin, wahllos einzelne grundlegende Bibliotheken auszutauschen. Prüfe stattdessen, ob der Anbieter eine zu deinem System passende Ausgabe bereitstellt oder ob eine andere unterstützte Installationsform verfügbar ist.
Den Inhalt eines AppImages entpacken
------------------------------------
Bei verbreiteten AppImages vom Typ 2 kannst du den Inhalt mit folgendem Aufruf entpacken:
```
./Beispielprogramm.AppImage --appimage-extract
```
Dabei entsteht im aktuellen Verzeichnis normalerweise der Ordner:
```
squashfs-root/
```
Die entpackte Anwendung lässt sich anschließend über ihren Einstiegspunkt starten:
```
./squashfs-root/AppRun
```
Das kann bei bestimmten Startproblemen oder zur Untersuchung des Dateiaufbaus hilfreich sein. Es ist aber keine reguläre Installation über die Paketverwaltung.
Auch der Aufruf mit `--appimage-extract` führt den Laufzeitteil der AppImage-Datei aus. Verwende ihn deshalb nicht als vermeintlich sichere Untersuchung einer unbekannten Datei.
Ist ein AppImage sicher abgeschirmt?
------------------------------------
Das AppImage-Format selbst stellt keine allgemeine Sandbox bereit. Ohne zusätzliche Abschirmung kann die gestartete Anwendung grundsätzlich auf Dateien und Ressourcen zugreifen, die für deinen Benutzer erreichbar sind.
### Zusätzliche Abschirmung mit Firejail
Auf der AppImage-Website wird darauf hingewiesen, dass AppImages mit einer zusätzlichen Sandbox wie **Firejail** ausgeführt werden können. Das ist kein Widerspruch: AppImage stellt die Anwendung bereit, Firejail ergänzt die Abschirmung.
Firejail kann beispielsweise den Zugriff auf bestimmte Verzeichnisse, Netzwerkverbindungen und weitere Systemfunktionen einschränken. Welche Einschränkungen tatsächlich gelten, hängt vom verwendeten Sicherheitsprofil und den gewählten Einstellungen ab. Ein Sicherheitsprofil ist dabei ein Satz von Regeln für die gestartete Anwendung.
Wenn Firejail auf deinem System eingerichtet ist, kannst du ein unterstütztes AppImage beispielsweise so starten:
```
firejail --appimage ./Beispielprogramm.AppImage
```
Dabei bedeutet:
| Bestandteil | Erklärung |
|---|---|
| `firejail` | Startet die Anwendung mit zusätzlicher Abschirmung. |
| `--appimage` | Aktiviert die besondere Unterstützung für AppImages. |
| `./Beispielprogramm.AppImage` | Gibt an, welche Datei gestartet werden soll. |
Firejail versucht anhand des Dateinamens, ein passendes Anwendungsprofil auszuwählen. Wird keines gefunden, verwendet es sein Standardprofil. Deshalb solltest du prüfen, welches Profil geladen wird und ob dessen Regeln zu deinen Anforderungen passen.
### Eine Sandbox ist keine Sicherheitsgarantie
Firejail kann Zugriffe begrenzen, macht eine unbekannte Anwendung aber nicht automatisch vertrauenswürdig. Manche Programme funktionieren unter strengen Einschränkungen außerdem nur teilweise oder benötigen angepasste Regeln. Auch Sandbox-Werkzeuge besitzen Grenzen und müssen aktuell gehalten werden.
Für den sicheren Umgang bleiben deshalb wichtig:
- vertrauenswürdige Bezugsquellen,
- regelmäßige Aktualisierungen,
- das Starten ohne unnötige administrative Rechte,
- passende Systemvoraussetzungen,
- ein bewusster Umgang mit unbekannten ausführbaren Dateien.
Eine heruntergeladene Anwendung bleibt ausführbarer Programmcode – auch wenn sie bequem in einer einzigen Datei verpackt ist. Eine zusätzliche Sandbox kann Risiken begrenzen, ersetzt aber nicht das Vertrauen in die Herkunft der Software.
Die wichtigsten Befehle im Überblick
------------------------------------
In den Beispielen befindet sich die Datei im aktuellen Verzeichnis und heißt `Beispielprogramm.AppImage`.
| Aufgabe | Befehl |
|---|---|
| Für den Eigentümer ausführbar machen | `chmod u+x Beispielprogramm.AppImage` |
| Anwendung starten | `./Beispielprogramm.AppImage` |
| Temporär entpacken und starten, falls unterstützt | `./Beispielprogramm.AppImage --appimage-extract-and-run` |
| Inhalt eines Typ-2-AppImages entpacken | `./Beispielprogramm.AppImage --appimage-extract` |
| Entpackte Anwendung starten | `./squashfs-root/AppRun` |
| Verzeichnis für unterstützten portablen Home-Modus anlegen | `mkdir Beispielprogramm.AppImage.home` |
Die zusätzlichen AppImage-Optionen hängen von der enthaltenen Laufzeit und dem AppImage-Typ ab. Für den normalen Gebrauch reichen meist das Setzen des Ausführungsrechts und der anschließende Start.
Fazit
-----
AppImage macht die Bereitstellung einzelner Linux-Anwendungen einfach: Datei herunterladen, ausführbar machen und starten. Viele benötigte Bestandteile sind bereits enthalten, während bestimmte Anforderungen an das Linux-System bestehen bleiben.
Die unkomplizierte Verteilung ersetzt jedoch keine Pflege. Du solltest wissen, woher die Anwendung stammt, wie sie aktualisiert wird und wo sie ihre Daten speichert. Außerdem ist ein AppImage nicht automatisch abgeschirmt – die einzelne Datei ist ein Verteilungsformat, kein Sicherheitsversprechen.
AppImage unter Linux: Anwendungen herunterladen, starten und verwalten
Submitted 23 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78513