How do I free up disk space on Mac for developers?
To free up disk space on a Mac for developers, the fastest wins are dev caches, not photos: Xcode DerivedData and simulators, Android/Gradle, Docker build cache, and stale node_modules. They hide inside macOS's opaque "System Data". A typical dev reclaims 20-50 GB, and machines with years of Xcode, Android and Docker hit 100+ GB. GRUJ scans them all in one pass, shows real sizes, and deletes only what is regenerable. Run gruj scan.
brew install --cask fan2dev/tap/gruj 3 months free · no card · direct download (outside the App Store)
Your disk is full and macOS won't tell you what's in "System Data"
Open Storage settings and you see a giant "System Data" slab — 100, 150, 200 GB — with no breakdown. That bucket is where macOS files most dev junk: Xcode build artifacts, simulator runtimes, Gradle caches, the Docker disk image, package-manager stores. Finder won't show you what's inside, so you delete photos and downloads and barely move the needle. One dev reported going 257 GB → 88 GB cleaning just Android Studio and Xcode; another freed 100 GB. None of it is your source code — it's all regenerable. GRUJ exists to crack open that opaque "System Data" into named categories with real sizes, so you delete the bloat instead of your files.
gruj scan — break open System Data
Run gruj scan. GRUJ walks your dev tooling and prints what's actually inside the "System Data" macOS hides: Xcode DerivedData and simulators, Gradle and Android SDK, Docker's reclaimable layers, node_modules, Homebrew, Flutter's .pub-cache, Python and Rust caches — each with its real on-disk size. No du -sh marathon, no guessing.
Pick the categories worth clearing
Every category shows its size so you target the biggest first — usually DerivedData, the Docker build cache and old simulator runtimes. You choose what to clear; GRUJ only ever offers paths on its regenerable allowlist, so source, repos and signing data are off the table.
gruj clean — one confirmed pass for everything
Instead of rm -rf DerivedData, then docker system prune, then find node_modules, then brew cleanup, then simctl delete — run gruj clean once. It deletes only regenerable caches and builds after you confirm, and the tools rebuild them the next time you build, pull or install.
Xcode: DerivedData, simulators, DeviceSupport
~/Library/Developer/Xcode/DerivedData is 1-5 GB per project and reaches 30-50 GB across many; iOS DeviceSupport stacks 2-5 GB per device version; old simulator runtimes are several GB each. GRUJ clears them safely — Xcode regenerates on the next build. See the Xcode DerivedData guide for the deep dive.
Android & Gradle: caches, AVDs, system images
~/.gradle/caches grows with every dependency, each API system image is 1.5-3 GB, and AVDs in ~/.android/avd plus the SDK in ~/Library/Android/sdk add up fast — often 10-100 GB total. GRUJ clears the regenerable parts; full walkthrough in the Gradle cache guide.
Docker: images, volumes, build cache
The silent killer is build cache (100% reclaimable, easily 10-20 GB) — almost nobody runs docker system df to see it. GRUJ shells out to Docker only if it's installed, surfaces the reclaimable layers, and skips volumes with data unless you say otherwise. Docker's VM disk defaults to a 64 GB cap.
node_modules + package-manager stores
A React/Next.js node_modules is 200-500 MB; dozens of dead repos mean tens of GB. GRUJ finds every node_modules and prunes the npm/pnpm/yarn/bun stores in the same scan, with sizes shown. Details in the delete node_modules guide.
Simulators, CocoaPods, Rust, Python
CoreSimulator devices and runtime images (~13 GB of images alone), CocoaPods cache (~/Library/Caches/CocoaPods, 5-20 GB), Rust target/ and sccache (10 GB default), Python venvs and pip caches — all regenerable, all scanned and sized in one pass.
Homebrew, Flutter & general caches
brew cleanup drops old formula downloads, Flutter's ~/.pub-cache holds every package version, and ~/Library/Caches fills with logs and tool junk. GRUJ sweeps these alongside the heavy hitters, so the whole "System Data" mystery becomes a list you can act on.
GRUJ vs the usual options for clearing dev space
| GRUJ | Various apps/commands | |
|---|---|---|
| Covers all dev tools (not just Xcode) | Yes — Xcode, Android, Docker, node, Rust, Python, brew in one pass | Xcode-only tools miss the rest; generic cleaners miss dev bloat entirely |
| Breaks down opaque "System Data" | Yes — named categories with real sizes | Finder/Settings show one unlabeled blob |
| Deletes only regenerable junk | Yes — fixed allowlist, never touches repos/data | Free-form rm -rf or broad sweeps risk real files |
| One pass for everything | One scan + one confirmed clean | A different command per tool, run by hand |
| Distribution & trust | Apple-notarized direct download + Homebrew, real CLI (gruj) | Mixed: App Store sandbox limits, or paid subscriptions |
| Cost | Free right now in early access (macOS 13+) | Generic suites are subscription-based |
FAQ
What's the best way to free up disk space on a Mac for development?
Target dev caches, not personal files. The biggest wins are Xcode DerivedData and simulators, Android/Gradle caches, the Docker build cache, and stale node_modules — all regenerable. Run gruj scan to see each with its real size, then gruj clean removes only what you confirm. A typical dev reclaims 20-50 GB.
What is "System Data" on a Mac and why is it so big?
"System Data" is the catch-all bucket macOS Storage uses for anything it can't categorize — which includes most developer caches: Xcode build artifacts, simulator runtimes, Gradle caches, the Docker disk image, and package-manager stores. It looks huge because Finder won't show what's inside; GRUJ breaks it into named categories with sizes.
Is it safe to delete developer caches to free space?
Yes, when you only delete regenerable junk. DerivedData, simulator runtimes, Gradle/npm/pnpm caches and Docker build cache all rebuild automatically on the next build, pull or install. GRUJ deletes only against a fixed regenerable allowlist and asks before touching anything — it never deletes your source code, repos, lockfiles or signing keys.
How do I free up 30-50 GB (or 100 GB) on my Mac as a developer?
Clear the heavy regenerable caches. Xcode DerivedData and simulators often total 30-60 GB, Android/Gradle adds 10-100 GB, and Docker build cache 10-20 GB. Devs have reported reclaiming 100-168 GB cleaning just Xcode and Android Studio. gruj scan shows your real numbers before you delete a thing.
Why is Docker taking up so much space on my Mac, and won't Docker.raw shrink?
Docker stores images, volumes and build cache in a single VM disk image (Docker.raw, capped at 64 GB by default). Build cache is the usual culprit — run docker system df to see the "reclaimable" column. After pruning, the host file may stay large until the disk is compacted; GRUJ surfaces the reclaimable layers so you know what's actually recoverable.
Is a 256 GB MacBook enough for development?
It's tight but workable if you keep caches in check. Xcode, Android, Docker and node_modules can each balloon into tens of GB, so on 256 GB you'll fill up within months without cleanup. Regular gruj scan + gruj clean keeps the regenerable bloat off the disk so the space goes to your actual work.
Is GRUJ a CleanMyMac alternative for developers?
Yes. Generic cleaners flag a few GB of browser and system caches while missing the 40 GB of old node_modules, 25 GB of DerivedData and 18 GB of Docker that actually fill a dev's disk. GRUJ is built around dev tooling specifically, deletes only regenerable paths, ships notarized with a real CLI, and is free in early access.
Does GRUJ delete my projects or source code?
No. GRUJ uses a two-axis model: it only ever touches paths that are both regenerable and not your data. Source, repos, lockfiles, .env files, Xcode Archives with dSYMs and Docker volumes with data are off the allowlist. The flow is always scan → pick → confirm, and nothing is deleted until you say so.
Crack open "System Data" and reclaim your disk
One scan shows the real size of every Xcode, Android, Docker, node and Homebrew cache on your Mac. Delete only what's regenerable. Free right now in early access, macOS 13+.
Download free