Der Leitfaden zum Aufräumen der Festplatte für Entwickler (2026)

Die Liste Ready to free in Levo mit geöffneter Gruppe Xcode build data, darunter Simulators and emulators und die Device-Support-Dateien

Der Mac eines Entwicklers füllt sich an denselben zwölf Stellen: Build-Daten und Simulatoren von Xcode, node_modules, Paket-Caches, das Festplattenabbild von Docker, Sprach-Toolchains und KI-Modelle. Fast alles davon entsteht bei Bedarf neu. Es kommt also darauf an, zu wissen, welcher Ordner welcher ist, und den Aufräumbefehl des Tools zu nutzen statt rm.

Ökosystem	Wo es sich versteckt	Aufräumen mit	Anleitung
Build-Daten von Xcode	`~/Library/Developer/Xcode/DerivedData`	Settings › Locations, oder den Ordner löschen	DerivedData
Simulatoren und Runtimes	`~/Library/Developer/CoreSimulator`	`xcrun simctl delete unavailable`	Simulatoren
Device Support	`~/Library/Developer/Xcode/iOS DeviceSupport`	Ordner alter iOS-Versionen löschen	DeviceSupport
SwiftPM und CocoaPods	`~/Library/Caches/org.swift.swiftpm`, `~/Library/Caches/CocoaPods`	`swift package purge-cache`, `pod cache clean --all`	SwiftPM und CocoaPods
node_modules	Jeder JavaScript-Projektordner	Den Ordner löschen, dann `npm install`	node_modules
npm, pnpm, Yarn, Bun	`~/.npm`, der pnpm-Store, `~/.bun/install/cache`	`npm cache clean --force`, `pnpm store prune`	JavaScript-Caches
Docker	`Docker.raw` im Datenordner von Docker	`docker system prune`	Docker
Homebrew	`~/Library/Caches/Homebrew`	`brew cleanup`	Homebrew
Python	`~/Library/Caches/pip`, virtualenvs, conda	`pip cache purge`, `uv cache clean`	pip, uv und conda, virtualenvs
Rust	`target`-Ordner, `~/.cargo`	`cargo clean`	Rust
Go	`~/Library/Caches/go-build`, `~/go/pkg/mod`	`go clean -cache`	Go
Gradle und Android	`~/.gradle/caches`, `~/Library/Android/sdk`	`./gradlew clean`, AVD Manager	Gradle, Android-Emulatoren
Editoren	Caches von JetBrains, VS Code und Cursor	Die eigenen Ordner der jeweiligen App	JetBrains, VS Code und Cursor
Test-Browser	`~/Library/Caches/ms-playwright`	`npx playwright uninstall`	Playwright und Puppeteer
Game-Engines	Unity `Library`, Unreal `DerivedDataCache`	Den Ordner löschen, das Projekt neu öffnen	Unity und Unreal
KI-Modelle und Agenten	`~/.ollama`, `~/.cache/huggingface`, `~/.claude`	Der eigene Befehl des jeweiligen Tools	KI-Ballast

So machst du es selbst

Finde zuerst heraus, wohin der Platz gegangen ist. Eine Festplattenkarte ist der schnellste Weg, aber ein paar du-Befehle beantworten das meiste:

du -sh ~/Library/Developer ~/Library/Caches ~/.cache ~/.npm ~/.gradle ~/.cargo ~/.ollama ~/.claude 2>/dev/null
du -sh ~/Library/Containers/com.docker.docker 2>/dev/null

Geh dann in dieser Reihenfolge vor, das Größte und Sicherste zuerst.

Beende Xcode und leere die Build-Daten, dann die Simulatoren und das alte Device Support. Auf einem Mac mit jahrelangem Xcode sind das oft 50 bis 150 GB. Warum Xcode so groß wird erklärt jeden Ordner.
Räum Docker auf. Images und Build-Cache sind der sichere Teil, Volumes enthalten vielleicht eine Datenbank, an der dir etwas liegt.
Lösch node_modules- und target-Ordner von Projekten, die du seit Monaten nicht geöffnet hast. Mit dem Paketmanager holst du sie später zurück.
Führ die Aufräumbefehle der Paketmanager aus: brew cleanup, npm cache clean --force, pip cache purge, go clean -cache. Jeder Cache wird bei der nächsten Installation neu aufgebaut, was Zeit und Bandbreite kostet.
Sieh dir KI-Modelle und Agentenverlauf an. Modelle sind das Einzige hier, das es im Internet womöglich nicht mehr gibt, prüf sie also von Hand.

Die Regel, die dich sicher hält: Caches und Build-Ausgaben werden aus etwas anderem erzeugt. Archive, Datenbanken in Docker-Volumes, nicht gepushte Git-Arbeit, .env-Dateien und deine eigenen Modelle gehören nicht dazu.

Eine Routine, die funktioniert

Die meisten Entwickler fahren mit einer kleinen Gewohnheit besser als mit einer großen Säuberung. Miss einmal im Monat die Ordner aus dem Befehl oben und sieh nach, was gewachsen ist. Build-Daten von Xcode, der Build-Cache von Docker und node_modules in aufgegebenen Branches sind die üblichen Wachser, der Rest bewegt sich kaum.

Zwei Dinge lohnen sich einmalig. Leg große Modell-Caches mit ihren Umgebungsvariablen (OLLAMA_MODELS, HF_HOME) auf eine externe Festplatte und verkürz, wie lange deine Coding-Agenten Sessions behalten. Danach verlangsamt sich das Wachstum dauerhaft.

Und eine kurze Liste dessen, was du in Ruhe lässt, was auch immer ein Reiniger sagt: Xcode-Archive, die du ausgeliefert hast, Docker-Volumes mit einer Datenbank darin, .env- und Zugangsdaten-Dateien, SSH-Schlüssel und Git-Repositories mit nicht gepushter Arbeit. Nichts davon ist ein Cache, und nichts lässt sich aus dem Quellcode neu erzeugen. Bist du bei einem Ordner unsicher, öffne ihn, sieh dir die Daten an und frag deinen Agenten, was es ist, bevor du etwas löschst.

So macht es Levo

Levo führt einen Live-Index deiner Festplatte und gruppiert, was es findet, nach Art: Xcode-Build-Daten, Simulatoren, Paket-Caches, Docker-Images, Agent-Worktrees und mehr, jeweils mit Größe und Begründung. Die eingebauten Regeln kennen die Ordner oben. Dein eigener Agent, etwa Claude Code oder Codex, liest den Index und beurteilt, was veraltet ist, aber nur Levo löscht.

Mit Select › Smartly hakst du an, was auf deiner Bereinigungsstufe sicher ist. Modelle, Backups, virtuelle Maschinen und alles, was geöffnet ist, bleiben ohne Haken, damit du entscheidest. Levo prüft jeden Eintrag noch einmal, kurz bevor er gelöscht wird, und lässt alles in Ruhe, was Xcode oder ein Build gerade nutzt. Die Einzelheiten stehen unter Levo für Xcode-Entwickler, für Webentwickler und für Android-Entwickler.

FAQ

Was belegt auf dem Mac eines Entwicklers am meisten Platz?

Meist zuerst die Xcode-Daten: DerivedData, Simulatoren und ihre Runtimes sowie Device Support, dann das Festplattenabbild von Docker, node_modules-Ordner und KI-Modelle. Miss deinen Benutzerordner und den Library-Ordner, um zu sehen, was auf dich zutrifft.

Ist es sicher, Entwickler-Caches zu löschen?

Ja, bei Caches und Build-Ausgaben, denn das Tool erzeugt sie aus deinem Quellcode neu. Rechne mit einem langsameren nächsten Build oder einer langsameren Installation. Lösch keine Archive, Docker-Volumes, nicht gepushte Git-Arbeit oder Modelle, die du nicht erneut laden kannst.

Soll ich rm oder den Befehl des Tools nutzen?

Nutz den Befehl des Tools, wenn es einen gibt, etwa simctl für Simulatoren, docker prune, brew cleanup und swift package purge-cache. Er weiß, was in Benutzung ist. Einfaches Löschen ist bei DerivedData und node_modules in Ordnung.

Wie oft sollte ich einen Entwickler-Mac aufräumen?

Wenn der freie Speicher knapp wird oder nach dem Ende eines großen Projekts. Build-Daten und Caches wachsen nach, ein monatlicher Blick schlägt also eine jährliche Säuberung.