# Mole CLI tegenover de Mac-app: gratis terminal of betaalde GUI

> Kies de gratis CLI of de betaalde native app op basis van je werkwijze, gedeelde beveiligingsbestanden op schijf, en welke functies alleen in de CLI zitten.

Published: 2026-07-25 | Updated: 2026-10-18

Mole bestaat als twee programma's. `mo` is een gratis, open-source opdrachtregeltool, geïnstalleerd
met Homebrew en gelicentieerd onder GPL-3.0. Mole voor Mac is een betaalde native app met vijf
tabbladen en een aanwezigheid in de menubalk. Ze zijn geen proefversie en een pro-editie. Het zijn aparte
implementaties met overlappende taken en een kleine gedeelde laag op schijf, dus de ene kiezen
sluit de andere niet uit. Dit is een gids om de versie te kiezen die past bij hoe
je al werkt, en bij wat er gebeurt als je beide houdt.

## Korte vergelijking

| | Mole CLI (`mo`) | Mole voor Mac |
| --- | --- | --- |
| Licentie | Gratis, open source, **GPL-3.0** (niet MIT) | Betaalde propriëtaire app |
| Prijs | Gratis | **[$19](https://mole.fit/pricing.md)** eenmalig, 2 Macs, gratis updates |
| Installatie | `brew install mole` | Download van **mole.fit** |
| Verwijderbereik | Breder (gaat ervan uit dat je de lijst leest) | Smaller (hetzelfde of veiliger dan de CLI) |
| Alleen terminal | `mo purge`, `mo installer`, `mo touchid`, `--dry-run` / `--json` | - |
| Alleen de app | - | GUI, menubalk, ventilatorregeling, opstarten, updates in de app, verwijderen via de prullenmand |
| Gedeeld op schijf | `~/.config/mole/whitelist*`, `~/Library/Logs/mole/operations.log` | Dezelfde paden |

## Wat de twee delen

Vijf opdrachten van de CLI komen rechtstreeks overeen met de vijf tabbladen van de app: `mo clean`,
`mo uninstall`, `mo optimize`, `mo analyze` en `mo status` horen bij Opschonen,
Apps, Optimaliseren, Analyse en Status. De categorieën herken je in beide:
overlappende families van gebruikers-, ontwikkelaars-, browser- en systeemcaches, app-inventaris en
het vinden van restbestanden, schijfanalyse en gezondheidsmetingen. De implementaties en de exacte
kandidaatsets zijn niet identiek.

Scannen is in beide gratis. De app rekent alleen het destructieve deel, en elk
destructief hulpmiddel werkt twee keer voordat een licentie nodig is, zodat je de scan van de app
op dezelfde Mac kunt vergelijken met die van de CLI zonder iets te betalen.

De interessantere overlap zit op schijf. Beide schrijven naar `~/.config/mole/whitelist` en
`~/.config/mole/whitelist_optimize`, en beide voegen toe aan
`~/Library/Logs/mole/operations.log`. Een cache die je in de ene voorkant beschermt, is beschermd
in de andere, en een verwijdering in een van beide laat een regel achter in hetzelfde bestand. De twee
programma's weten tijdens het draaien niets van elkaar, maar ze zijn ook niet onafhankelijk.

## Wat alleen de terminal kan

Drie grotere CLI-workflows hebben geen equivalent in de app. Ondersteunende opdrachten zoals
`mo history`, `mo update`, `mo completion` en `mo remove` zijn terminalbeheer,
geen extra onderhoudsoppervlakken.

### `mo purge`

Scant je projectmappen en biedt aan zware build-artefacten te verwijderen. De doellijst
is breed: `target`, `build`, `dist`, `.next`, `DerivedData`, `__pycache__`,
`coverage`, en ongeveer dertig meer, inclusief afhankelijkheidsmappen die een pakketbeheerder
opnieuw zou moeten downloaden. Purge verwijdert definitief in plaats van naar de
prullenmand te verplaatsen, en markeert projecten die in de laatste zeven dagen zijn aangeraakt als recent en laat ze
ongeselecteerd. Het is een directe manier om tientallen gigabytes terug te winnen op een ontwikkelaarsmachine,
en ook de opdracht die het meest een `--dry-run` eerst verdient.

### `mo installer`

Haalt DMG-, PKG- en archief-installatieprogramma's weg uit Downloads, het bureaublad, Homebrew-caches,
iCloud en Mail, en labelt elk naar waar het vandaan kwam.

### `mo touchid`

Stelt Touch ID in voor `sudo`. Dat is een shellconfiguratie, geen
opschoontaak.

De terminal ondersteunt ook voorbeelden en scripts. `mo clean`, `mo uninstall` en
`mo optimize` accepteren `--dry-run`, dat de geplande acties toont zonder ze uit te
voeren. `mo analyze`, `mo status` en `mo history` accepteren `--json`, en `mo status`
schakelt zelf naar JSON als de uitvoer door een pipe gaat, zodat een gezondheidscontrole een
script kan voeden. De alleen-lezen paden en de paden met gestructureerde uitvoer werken ook over ssh, op een Mac zonder scherm,
of in scripts. Geplande verwijdering heeft nog steeds een expliciet niet-interactief beleid nodig.
Het interactieve bevestigingsscherm wordt niet veilig alleen omdat cron het heeft gestart.

## Wat alleen de app kan

De toevoegingen van de app clusteren rond twee dingen waar de terminal slecht in is: doorlopende
weergave en systeembeheer met extra rechten.

Voor weergave tekent Analyse een treemap waar je in kunt duiken, Status toont een live bento-dashboard met sparklines en vast te pinnen processen, en een HUD in de menubalk houdt CPU, geheugen
en netwerk zichtbaar terwijl je in iets anders werkt. Verwijderen toont een controleplan
met paden, eigenaren en groottes voordat er iets beweegt, en verwijderingen gaan naar de prullenmand
in plaats van meteen gewist te worden.

Voor systeembeheer installeert de app een nauw begrensd root-hulpprogramma via SMJobBless
voor schrijfacties naar ventilator en ondersteunde batterij. Opstartbeheer volgt een aparte grens:
gevalideerde launchd-taken en ondersteunde Service Management-onderdelen kun je aan- en uitzetten, terwijl
niet-gekoppelde achtergrondonderdelen Systeeminstellingen openen in plaats van te worden geraden. De app
heeft ook oppervlakken die alleen als vaste app zin hebben: de privacycontrole, die
live gebruik van camera en microfoon meldt, Bescherming bij opladen, die de lading op ondersteunde Macs rond 75 tot
80 procent houdt, Scherm aan houden, Scherm schoonmaken om het toetsenbord af te nemen, en
een alleen-lezen Diagnose die een diagnoserapport samenstelt dat je in een melding kunt plakken.

Het grootste oppervlak dat alleen de app heeft, is het bijwerken van andere apps. Het herkent meerdere updatekanalen
en heeft paden in de app voor Sparkle, Homebrew-casks en -formulae, de Mac App Store en
Electron-feeds. GitHub Releases en websitemetadata kunnen extra versies herkennen.
Als Mole een bundle niet veilig kan controleren en vervangen, opent het de app of de pagina van de leverancier
in plaats van een ander installatieprogramma te verzinnen. De licentie is een eenmalige aankoop voor twee
Macs met gratis updates, een terugbetaling binnen 14 dagen, en macOS 14 of nieuwer. Geen van beide programma's
stuurt telemetrie.

## Onder de motorkap: hoe één veiligheidsmodel twee voorkanten dient

De app is geen schil die `mo` aanroept. Het is een herimplementatie in Swift, en
de twee codebases delen paden en veiligheidsbeslissingen, geen processen. Analyse bouwt
op de padtaxonomie en de lessen over parallel opmeten van de CLI, maar heeft een eigen scanner,
time-outs, toestanden voor deelresultaten, cache en terugvalgedrag. Een totaal uit de ene voorkant
is daarom een nuttige kruiscontrole, geen belofte van byte-voor-byte gelijkheid.

Het principe in de repository om ze in de pas te houden is dat CLI-pariteit
hetzelfde of veiliger betekent, niet dezelfde verwijderbreedte. Elke kandidaat die de app toont
wordt geclassificeerd voordat hij bij je komt: standaard selecteerbaar, alleen ter controle en standaard uitgevinkt,
of ronduit geblokkeerd en geweigerd zelfs als iets erom vraagt. Als het
gedrag van de CLI en die classificatie botsen, neemt de app de smallere positie.

`mo purge` is het duidelijkste voorbeeld. De Mac-poort van die veeg laat bewust elke
gedownloade afhankelijkheidsmap weg die de CLI verwijdert, inclusief `node_modules`, `Pods`,
`venv` en `vendor`. De reden is herstelbaarheid: een gecompileerde map `target`
komt terug uit een lokale build, terwijl een afhankelijkheidsboom het netwerk nodig heeft en
iets anders kan opleveren dan wat geïnstalleerd was. De app biedt alleen aan wat puur
lokale compilatie opnieuw kan bouwen, en toont die als rijen ter controle in plaats van
vooraf geselecteerde rijen. Dezelfde asymmetrie zie je elders. De app zet scans van app-gegevens
achter Volledige schijftoegang, controleert elk pad opnieuw op het moment van verwijderen in plaats van
op het moment van scannen, en stuurt het verwijderen van apps via de prullenmand.

De twee zijn dus niet even agressief, en het verschil loopt in een vaste
richting. De CLI wint meer terug omdat hij uitgaat van iemand die de lijst leest. De app
wint minder terug omdat hij uitgaat van iemand die wil dat de lijst al veilig is.

<figure class="blog-diagram">
  <img src="https://mole.fit/img/blog/two-front-ends.webp" width="1360" height="454" loading="lazy" alt="Twee voorkanten, een terminaltool en een Mac-app, die dezelfde vijf bewerkingen apart uitvoeren maar hetzelfde whitelistbestand en hetzelfde bewerkingslogboek op schijf lezen en schrijven.">
  <figcaption>De twee programma's praten niet met elkaar terwijl ze draaien, maar ze delen een beschermingslijst en een logboek, dus een cache die in de ene is beschermd, is in beide beschermd.</figcaption>
</figure>

## Beide draaien

Er breekt niets als je beide installeert, en de gedeelde bestanden maken de combinatie
samenhangend. Bescherm een cache vanuit de instellingen van de app en `mo clean` slaat hem ook over. Voeg
een pad toe met `mo clean --whitelist` en de app respecteert het. Beide laten hun verwijderingen achter in
hetzelfde logboek.

Twee kanttekeningen die de moeite waard zijn. De programma's stemmen niet af terwijl ze draaien, dus start
niet tegelijk een opschoning in beide. En omdat de app bewust smaller is, is een
categorie in `mo clean` zien die de app nooit aanbiedt verwacht gedrag, geen ontbrekende
functie.

<figure class="blog-diagram">
  <img src="https://mole.fit/img/blog/same-or-safer.webp" width="1360" height="454" loading="lazy" alt="De verzameling die de CLI verwijdert, getekend rond de kleinere verzameling die de Mac-app verwijdert, met als verschil gedownloade afhankelijkheidsmappen zoals node_modules, Pods, venv en vendor.">
  <figcaption>Hetzelfde of veiliger, nooit breder. De mappen die alleen de CLI veegt, zijn de mappen die het netwerk nodig hebben om terug te komen.</figcaption>
</figure>

## Kiezen

Installeer de CLI als je in een terminal leeft, wilt voorvertonen met `--dry-run`,
`--json` nodig hebt voor een script, de veeg van projectartefacten en installatieprogramma's wilt, of gewoon geen
geld wilt uitgeven. Op een ontwikkelaarsmachine is dat vaak alles wat nodig is, en het is
gratis precies zodat dat kan.

Koop de app als je de schijfkaart en het live dashboard wilt, als ventilatorregeling, opstartbeheer
of updates van apps van derden de echte reden zijn dat je hier bent, of als je dit installeert
voor iemand die nooit Terminal opent. Dat laatste geval was de
oorspronkelijke reden dat de app bestaat, een verhaal dat staat in
[het verhaal van Mole](https://mole.fit/nl/blog/the-story-of-mole).

Als je het nog niet kunt zeggen, installeer dan eerst de CLI en draai `mo clean --dry-run`. Het kost
niets, het verwijdert niets, en de uitvoer lezen is de snelste manier om te leren of
je Mac een probleem heeft dat een tool waard is, een vraag die
[de moeite waard is vóór je een opschoonapp installeert](https://mole.fit/nl/blog/do-you-need-a-mac-cleaner).

---

Canonical HTML page: https://mole.fit/nl/blog/mole-cli-vs-mac-app
Blog index for agents: https://mole.fit/nl/blog/llms.txt
Site index for agents: https://mole.fit/llms.txt
