Wanneer je een programma installeert op Windows, denk je meestal aan dit proces:

1. Een `.exe` of `.msi` installatiebestand downloaden
2. “Volgende, Volgende, Voltooien”
3. Waar alles precies geïnstalleerd is, weet je eigenlijk niet (register + verspreide bestanden)

Op [[Linux]] bestaat er een totaal andere manier om apps te distribueren, die je op Windows zelden ziet.
Dat is **AppImage**.

Net zoals je op mobiel een APK-bestand downloadt en uitvoert om een app te laten werken, kun je op [[Linux]] **een complete desktop-app uitvoeren met slechts één bestand**. Zonder installatieproces, zonder pakketbeheerder, hoef je alleen maar “één uitvoerbaar bestand” te beheren.

In dit artikel behandelen we:

* **Wat** AppImage is
* Waarom het een manier is die **vooral Windows-gebruikers onbekend, maar aantrekkelijk vinden**
* En **hoe je AppImages het beste kunt beheren op [[Linux]]** (met name het gebruik van `/opt`)

---

## Wat is AppImage? {#sec-516aabf79f95}

In één zin samengevat:

> **AppImage = een “uitvoerbaar enkel bestand” dat een app en de benodigde bibliotheken bundelt.**

Dit betekent dat alles wat nodig is om een app uit te voeren, zoveel mogelijk in één geheel wordt verpakt en als **één uitvoerbaar bestand** wordt gedistribueerd.

Het gebruik is ook heel eenvoudig:

```bash
# 1. AppImage-bestand downloaden
$ ls
MyApp-1.0-x86_64.AppImage

# 2. Uitvoerrechten toekennen
$ chmod +x MyApp-1.0-x86_64.AppImage

# 3. Uitvoeren
$ ./MyApp-1.0-x86_64.AppImage
```

Dat is alles.
Het concept van "installatie" bestaat nauwelijks; als je het wilt verwijderen, verwijder je gewoon het bestand.

Vergeleken met Windows lijkt het op een **portable app**, maar AppImage heeft dit verder ontwikkeld tot een **standaardformaat voor het [[Linux]] desktop-ecosysteem**.

---

![Afbeelding](/media/whitedec/blog_img/56a402b8c81a468a9fba25fca6e14988.webp)

## Waarom is dit onbekend voor Windows-gebruikers? {#sec-01e86caebfff}

De traditionele Windows-methode houdt in:

* Een installatieprogramma dat:

  * Bestanden naar systeemmappen kopieert
  * Sleutels toevoegt aan het register
  * Diverse items zoals het Startmenu, services en stuurprogramma's registreert

Vanuit het oogpunt van de gebruiker resulteert dit in de situatie: "Ik heb het gewoon geïnstalleerd, maar er is van alles op onbekende plekken in het OS verschenen."

AppImage daarentegen:

* Heeft **geen register**
* Wijzigt **geen systeemdirectory's**
* Wordt **niet geregistreerd bij de pakketbeheerder**

Het bestaat als **één volledig onafhankelijk bestand**.
Het maakt niet uit waar je het plaatst; zolang het bestand er is, kan het worden uitgevoerd.

> Als Windows het "OS is waarvan ik het minst weet wat er op mijn computer is geïnstalleerd", dan toont AppImage op bestandsniveau "hier is precies de app die ik heb".

Dit sluit goed aan bij de filosofie van [[Linux]]:

* "Alles is een bestand"
* "Een structuur die de gebruiker begrijpt, in plaats van automatische magie"

AppImage biedt een zeer eenvoudig model: "app = één bestand".

---

## Voordelen van AppImage: Waarom is het zo handig? {#sec-8a5af0e4123a}

De redenen waarom mensen AppImage waarderen, zijn als volgt:

### 1. Geen installatieproces {#sec-1865f0f3a944}

* Het wordt niet geregistreerd bij een pakketbeheerder
* Er worden geen bestanden stiekem naar plaatsen zoals `/usr/bin` of `/usr/lib` gekopieerd
* Er is geen register of iets dergelijks

Het is gewoon “één uitvoerbaar bestand”.

### 2. Zeer eenvoudig te verwijderen/op te schonen {#sec-4a100ca49b34}

* Niet tevreden met de app? → Verwijder gewoon het bestand
* Je hoeft je geen zorgen te maken over “wat heeft deze app achtergelaten op mijn systeem?”

Hoewel configuratiebestanden wel kunnen worden aangemaakt op plaatsen zoals `~/.config`, is de **uitvoerbare binaire code zelf volledig zichtbaar en transparant**.

### 3. Makkelijk om 'Dependency Hell' te vermijden {#sec-db0637e0082c}

AppImage's bevatten meestal de bibliotheken die nodig zijn voor uitvoering. Daarom:

* Verschillende `glibc`-versies per distributie
* Incompatibele `libXxx.so`-versies

Deze problemen zijn vaak al **tot op zekere hoogte opgelost binnen de AppImage** zelf.
Voor de gebruiker betekent dit minder zorgen over “zal het ook op deze distributie werken?”.

### 4. Geen rootrechten nodig {#sec-02fd711bb81e}

In de meeste gevallen volstaat:

* De gebruiker downloadt het
* Rechten toekennen (`chmod +x`)
* Direct uitvoeren

Het is niet nodig om bestanden naar systeemdirectory's te kopiëren, dus het is **perfect bruikbaar zonder sudo**.

---

## Er zijn ook nadelen: Een afweging met pakketbeheerders {#sec-f3cac4e41a7f}

Natuurlijk is AppImage niet de ultieme oplossing. De belangrijkste nadelen zijn:

* **Moeilijk centraal te beheren**

  * Versies/updates zijn niet in één oogopslag te zien via een pakketbeheerder (apt, pacman, dnf, etc.)
* **Updateprocessen variëren**

  * Sommige AppImages hebben een ingebouwde updatefunctie, maar veel ook niet
* **Verhoogd schijfgebruik**

  * Omdat elke AppImage zijn eigen bibliotheken bevat, kan dit leiden tot meer duplicatie

Daarom is het realistischer om AppImage selectief te gebruiken, in plaats van voor alle apps:

* Voor apps met een omslachtig installatieproces
* Voor apps die je op meerdere distributies op dezelfde manier wilt gebruiken
* Voor minder gangbare tools of experimentele apps

---

## Waar AppImages plaatsen? Beheerstrategieën {#sec-584e8ff8a715}

Laten we nu overgaan op de praktische kant.
**Waar plaats je AppImage-bestanden en hoe beheer je ze?**

Er zijn verschillende stijlen onder [[Linux]]-gebruikers, maar grofweg zijn er twee benaderingen.

### 1. Gewoon in de home-directory plaatsen (`~/Apps`, `~/bin`, etc.) {#sec-e89628d037d9}

Toen ik net met [[Linux]] begon, deed ik dit ook:

* `~/apps/MyApp/MyApp.AppImage`
* Uitvoeren vanuit `~/Downloads` zonder het te verplaatsen
* Af en toe een map aanmaken om het te organiseren

**Voordelen**

* Geen rootrechten nodig
* Voor een “machine die ik alleen gebruik” is dit eigenlijk geen groot probleem

**Nadelen**

* Niet deelbaar als er meerdere gebruikersaccounts zijn
* Verwarring later bij het opruimen: “Was dit een AppImage? Wat is deze map?”
* Vanuit het oogpunt van het [[Linux]]-bestandssysteem worden “systeembrede apps” en “mijn persoonlijke gegevens” gemengd

Hoewel dit een prima methode is voor een persoonlijke laptop die je alleen gebruikt,
past de volgende methode beter als je het op een meer **“[[Linux]]-achtige manier”** wilt beheren.

### 2. Beheer per app-directory onder `/opt` {#sec-d7d03525e948}

Dit is ook de methode die ik persoonlijk prefereer.

1. Maak voor elke app een aparte directory aan onder `/opt`
2. Plaats het AppImage-bestand in die directory
3. Configureer de rechten en groepen correct voor delen met meerdere gebruikersaccounts

Als je bijvoorbeeld `MyApp.AppImage` wilt beheren:

```bash
# 1. Maak een app-specifieke directory aan
sudo mkdir -p /opt/myapp

# 2. Verplaats de AppImage
sudo mv ~/Downloads/MyApp-1.0-x86_64.AppImage /opt/myapp/myapp.AppImage

# 3. Ken uitvoerrechten toe
sudo chmod 755 /opt/myapp/myapp.AppImage
```

En als je de `myapp`-opdracht overal in het systeem wilt kunnen uitvoeren:

```bash
sudo ln -s /opt/myapp/myapp.AppImage /usr/local/bin/myapp
```

Dit resulteert in:

* **De daadwerkelijke locatie van het uitvoerbare bestand:** `/opt/myapp/myapp.AppImage`
* **De opdracht die in de PATH wordt opgepikt:** `/usr/local/bin/myapp`

#### Als je de rechten strenger wilt beheren

Als je bijvoorbeeld alleen een specifieke groep uitvoerrechten wilt geven:

```bash
# Maak een groep genaamd 'myapps' aan
sudo groupadd myapps

# Wijzig de groep van de directory en het bestand naar 'myapps'
sudo chown -R root:myapps /opt/myapp

# Alleen eigenaar/groep mag uitvoeren (anderen blokkeren)
sudo chmod 750 /opt/myapp/myapp.AppImage
sudo chmod 750 /opt/myapp
```

Nu kunnen alleen gebruikers die lid zijn van de `myapps`-groep deze AppImage uitvoeren.

```bash
sudo usermod -aG myapps alice
sudo usermod -aG myapps bob
```

De voordelen van deze methode zijn:

* **Sluit goed aan bij de intentie van het [[Linux]]-bestandssysteem**

  * `/opt` is bedoeld voor “applicaties die niet zijn opgenomen in de distributiepakketten”
* Meerdere gebruikersaccounts kunnen één app delen en gebruiken
* Via rechten/groepen kun je op bestandsysteemniveau bepalen “wie welke app mag gebruiken”

---

## Integratie met de desktopomgeving (.desktop-bestand) {#sec-04643b9eaa92}

Als je een AppImage niet alleen als bestand wilt gebruiken, maar het ook zichtbaar wilt maken in het menu van je desktopomgeving (zoals GNOME/KDE), kun je een `.desktop`-bestand aanmaken.

Bijvoorbeeld:

`~/.local/share/applications/myapp.desktop`:

```ini
[Desktop Entry]
Type=Application
Name=My App
Exec=/opt/myapp/myapp.AppImage
Icon=/opt/myapp/icon.png
Terminal=false
Categories=Utility;
```

Op deze manier:

* Verschijnt “My App” in het applicatiemenu
* En bij een klik wordt `/opt/myapp/myapp.AppImage` uitgevoerd.

Als je wilt dat het systeembreed zichtbaar is, plaats je het onder `/usr/share/applications/`.
Ook dit is, onafhankelijk van de pakketbeheerder, een **structuur waarbij je alleen bestanden hoeft toe te voegen/verwijderen**, wat het beheer zeer eenvoudig maakt.

---

## Conclusie: De [[Linux]]-filosofie in "één bestand" {#sec-032a7eba661f}

AppImage is op zichzelf een distributiemethode die de filosofie van [[Linux]] goed weerspiegelt:

* **Transparantie**

  * Je ziet op bestandsniveau waar de app zich bevindt en wat er wordt uitgevoerd.
* **Gebruikersgestuurd**

  * In plaats van dat een installatieprogramma het systeem willekeurig wijzigt, bepaalt de gebruiker zelf waar de bestanden worden geplaatst.
* **Eenvoud**

  * Installatie/verwijdering is geen complexe tovenarij, maar teruggebracht tot “bestanden kopiëren/verwijderen”.

Dit is een model dat je zelden ziet op Windows.
Voor mensen die moe zijn van het gevoel dat “na installatie er van alles ergens in het OS wordt opgestapeld”, kan AppImage een verfrissende ervaring zijn.

Als je begint met het gebruiken van AppImage:

* In het begin kun je het gewoon in je home-directory plaatsen
* Als je er eenmaal aan gewend bent, is het aan te raden om het te organiseren onder `/opt/appnaam`
* En zelfs te integreren met groepsrechten, symbolische links en `.desktop`-bestanden.

Als je dit doet, kun je:

* **Zeer duidelijk begrijpen hoe apps op je systeem zijn gedistribueerd**
* **En wie toegang heeft tot welke apps**

Persoonlijk denk ik dat dit een van de redenen is waarom je [[Linux]] zou moeten gebruiken.

**Lees ook**

- [De `/usr`-directory op Linux: 'Unix System Resources', geen 'User'?](/ko/whitedec/2025/12/5/linux-usr-directory-identity/)