The Mac Cleaner for Developers, Bought Once

Is there a Mac app that cleans all my developer caches, not just Xcode?

Why Xcode-only cleanup leaves gigabytes on the table

Most disk-space advice for developers stops at Xcode. Delete DerivedData, wipe old simulator runtimes, done. That reclaims real space, but it is a fraction of what a working machine accumulates. Docker keeps dangling image layers after every rebuild. Every project you cloned last quarter still carries a full node_modules tree. Gradle, CocoaPods, Carthage, and npm each keep their own cache. And the newest hog is the one no Xcode guide mentions: AI tooling. A single-toolchain cleaner cannot see any of that, so the gigabytes it does not know about sit untouched.

The toolchains DevCleaner scans in one run

DevCleaner runs one scan across roughly 22 toolchains at once rather than asking you to hunt each cache down by hand. The count is approximate and the app’s own site is the place to confirm the current list, but the coverage spans the categories that actually fill a developer’s SSD:

• Apple and native build tools: Xcode DerivedData, simulator runtimes, device support files, and archives.

• Containers and package managers: Docker images and layers, npm, Gradle, and the other per-language caches that pile up per project.

• AI tools: caches from Cursor, Claude, and Ollama, including local model weights that macOS never surfaces on its own.

That last group is the real reason a general Mac cleaner is not enough anymore. The demo at the top of this page shows the scan in miniature, one row per toolchain, each tagged by risk.

Where your Mac disk space actually goes

Xcode DerivedData and simulator runtimes

Xcode is the classic offender, and for good reason. DerivedData routinely reaches 30 to 50GB or more on an active development machine, and it is only the start. Xcode’s build system keeps intermediates it regenerates on demand, which is exactly why clearing them is safe: the cost is a slower next build, not a broken project. Simulator runtimes are the single largest category and can climb into the tens or even 150GB when beta runtimes stack up, and device support files re-download when a device needs them again. Between DerivedData, runtimes, and old archives, a full Xcode install can grow past 80 to 150GB.

Docker images and node_modules

Docker is designed to accumulate. Every rebuild can leave dangling layers behind, and Docker’s own docs describe docker system prune as the way to reclaim images, containers, and build cache you are no longer using. On a busy machine that reclaimable pile reaches tens of gigabytes without you noticing. node_modules is the other quiet multiplier: every project keeps its own tree, so ten dormant repos on disk mean ten full dependency copies you are not touching. Neither shows up as a single obvious folder in Finder, which is why they hide so well.

Clear Ollama and Cursor cache on a Mac

The AI tools are the newest and least visible. Local model weights, like the ones Ollama stores in ~/.ollama/models, run to tens of gigabytes each, and macOS Storage Management does not surface that hidden folder at all. VS Code-based editors like Cursor accumulate unbounded workspace storage over time, and Claude leaves caches of its own. These are generally safe to clear as long as an active session’s credentials are left alone, which is precisely the distinction a generic cleaner cannot make. On Apple Silicon, where RAM and GPU share one memory pool, freeing disk-backed model storage matters more than it used to, not less.

How DevCleaner cleans safely instead of guessing

The Safe, Warning, Danger rating model

Every category the scan turns up carries one of three grades. Safe is a regenerable cache, like DerivedData or npm’s store, that a tool rebuilds automatically; it is pre-selected because clearing it costs only build time. Warning is something you should look at before wiping, such as a node_modules tree a project might still be using or a model you may want to keep. Danger is the category most likely to cost you something you cannot get back, and it is never pre-selected. The grade is not a suggestion buried in a tooltip; it is the organizing principle of the whole scan, so the risky rows and the harmless ones are never lumped into one big “clean everything” button.

Safe dry-run cache cleanup on a Mac

The scan is a preview before it is a deletion. DevCleaner shows the full result, sized and graded, and removes nothing until you confirm. That is the difference between a cleaner you trust and one you audit: instead of hoping an algorithm targeted the right paths, you read the list, uncheck a cache a live project still needs, and clean the rest. Danger rows start unchecked, so the default action never touches them. You opt in to risk deliberately, one checkbox at a time, rather than opting out of it under time pressure.

The credential deny-list

Some files should never be offered for deletion at all. DevCleaner keeps a hard deny-list for the ones that hold logins and credentials, so an active session’s tokens or a saved login are never presented as a checkbox in the first place. This is the guardrail that lets the AI-tool coverage stay aggressive about reclaiming model weights and workspace storage without ever putting the thing that keeps you signed in on the chopping block.

Beyond deleting: Project Hibernation and automation

Project Hibernation for dormant repos

Hibernation is the feature that separates DevCleaner from a plain cache wiper. A repo you have not opened in three months still carries its build artifacts, its dependency tree, and its intermediates, and deleting the whole project to reclaim that space means re-cloning and re-setting-up when you come back. Hibernation strips the regenerable weight and leaves the project itself intact, so you get the gigabytes back now and the project rebuilds when you reopen it. It treats a dormant repo as something to park, not something to lose.

Auto Clean and Smart Triggers

Auto Clean and Smart Triggers move the whole workflow from something you remember to do to something that happens on its own. Auto Clean runs the safe categories without a manual scan each time, and Smart Triggers fire cleanup on a condition you set rather than a date on a calendar. Both are Pro features, and both stay inside the same safety model: automation acts on the Safe grade, so the categories that can cost you something are still the ones you review by hand.

Who DevCleaner fits, and who it does not

Best fit: multi-toolchain and AI-tool developers

The clearest fit is anyone whose disk fills from more than one direction:

• An iOS developer whose Xcode DerivedData, simulator runtimes, and old archives eat the SSD faster than any other single category.

• A full-stack or backend developer juggling Docker images, npm, and a stack of dormant node_modules trees across a dozen repos.

• An AI-tool user running Ollama models locally and living in Cursor or Claude, where tens of gigabytes hide in folders macOS never shows.

• Anyone who would rather run one reviewed scan than remember five separate terminal commands and the exact paths each one needs.

Weaker fit: Xcode-only or non-Mac users

DevCleaner is macOS only, so Windows and Linux developers are out from the start. If your entire toolchain is Xcode and nothing else, the breadth is wasted on you, and clearing DerivedData by hand or with a single-purpose cleaner covers the case for free. And if you are genuinely comfortable scripting your own rm -rf, docker system prune, and npm cache clean and keeping the paths straight, the value here is the safety model and the one-pass review, not access to anything you could not run yourself. The comparison below draws those lines with prices attached.

How DevCleaner compares: a cleanmymac alternative for developers

Subscription cleaners vs buy-once tools

The clearest money argument is against renting. CleanMyMac is a general Mac cleaner that runs on a subscription, and it handles developer caches generically, without the build-critical context to tell a regenerable cache from an archive you cannot rebuild. A developer-specific tool understands each toolchain’s layout and grades the risk instead of treating every cache the same. Paying once rather than yearly also means the cost of a tool you run a few times a month stops climbing after the first payment.

Developer-specific scanners vs disk visualizers

DaisyDisk and DiskCleaner are cheaper, and they do a genuinely different job. DaisyDisk maps your disk so you can see what is large, but it has no idea whether a big folder is a safe cache or a live project, so the safety call is entirely yours. DiskCleaner shows every file before removal, which is transparency-first but thin on developer toolchains. DeepClean is the closest rival in spirit, a buy-once developer scanner that markets a 17-toolchain count and sends deletions to the Trash. DevCleaner’s answer to all three is coverage of developer and AI-tool caches together, graded by risk, in one reviewed pass.

Where DevCleaner is honestly not the winner

Be clear about the trade. If price is the only axis you care about, DevCleaner loses: DaisyDisk and DiskCleaner are cheaper one-time buys, AppCleaner and manual terminal commands cost nothing, and DeepClean claims more raw toolchains. DevCleaner earns its $29 with purpose-built developer and AI-tool coverage in a single pass, an explicit Safe, Warning, Danger safety model, and Project Hibernation, all as a one-time purchase with no subscription. If none of those three things matter to you, one of the cheaper or free options is the better buy, and this article would rather say so than pretend otherwise.

Clearing Xcode, Docker, and node_modules caches in one workflow

The scan, review, clean sequence

Clean Xcode, Docker, and node_modules caches together

The point of the single pass is that you stop juggling commands. The manual route is three separate operations against three tools: clearing Xcode’s build intermediates, running docker system prune, and running npm cache clean, each with its own syntax and its own chance of targeting the wrong path. Each of those caches is self-healing by design, which is what makes clearing them safe. DevCleaner folds all three into one reviewed action so you get the safety of the built-in commands without having to remember any of them. And because the same scan also covers Docker, npm, Gradle, Cursor, Claude, and Ollama, the caches a per-command workflow would miss are on the list too, graded and ready to clean.

Frequently asked questions

Sources

1. 1

   Apple Developer: Build system and DerivedData locations

   Apple’s reference for Xcode’s build system, the source of the regenerable intermediates DevCleaner rates Safe to clear.

2. 2

   Docker docs: Prune unused Docker objects (docker system prune)

   The authoritative account of how Docker accumulates reclaimable images and layers and how that space is safely pruned.

3. 3

   npm docs: npm cache and the cache clean command

   Official confirmation that the npm cache is self-healing and safe to clear, which anchors the unified-workflow safety claims.