Clean pipx Environments on Mac

Xcode's DerivedData folder at ~/Library/Developer/Xcode/DerivedData stores build products, indexes, and logs for every project you have ever opened. Over time it can grow to 20–60 GB. Old iOS, watchOS, and tvOS Simulator runtimes in ~/Library/Developer/CoreSimulator accumulate with every Xcode update, adding another 10–30 GB. Archives from past App Store submissions, device support files for every iPhone and iPad you have connected, and Swift Package Manager caches add even more. CodeCleaner scans all of these locations, shows you the size of each DerivedData subfolder, simulator runtime, and archive, and lets you selectively remove stale entries without affecting your active builds. This is the single largest source of reclaimable space for most iOS and macOS developers.

JavaScript and TypeScript developers accumulate massive package caches over time. The npm cache at ~/.npm, yarn cache at ~/Library/Caches/Yarn, and pnpm store at ~/.pnpm-store can each grow to several gigabytes. On top of that, every project's node_modules folder contains a full copy of its dependencies — and if you have dozens of projects, that adds up to tens of gigabytes fast. CodeCleaner includes a dedicated node_modules scanner that finds every instance across your entire filesystem, lets you sort by size or last-used date, filter out small or tooling directories, and remove them safely in bulk. You can always regenerate them with a single npm install, yarn install, or pnpm install when you return to a project. The separate Dev Caches module handles the global npm, yarn, and pnpm caches.

Rust developers accumulate crate downloads in ~/.cargo/registry, git checkouts in ~/.cargo/git, and multiple toolchain versions under ~/.rustup/toolchains. After months of development across multiple projects that pull in hundreds of crate dependencies, these directories can consume 3–10 GB or more. Each project also generates a target/ directory with compiled artifacts that can be several gigabytes per project. CodeCleaner detects your Rust installation, calculates the size of each cache component, and lets you clean the registry and git caches without removing your active toolchains. The Project Scanner module separately finds and sizes every target/ directory across your projects.

Python's package ecosystem creates caches in ~/.cache/pip, ~/Library/Caches/pypoetry, and Conda/Miniconda/Anaconda installations. Each virtualenv duplicates the Python interpreter and all installed packages, so a handful of projects can easily consume several gigabytes. Add pyenv installations, pipx environments, and tool caches from Ruff, mypy, and pre-commit, and the total grows further. CodeCleaner identifies all of these cache locations — pip, Poetry, Conda, pyenv, pipx, Ruff, mypy, and pre-commit — shows you the total size, and lets you reclaim space from stale downloads and unused virtualenvs while keeping your active environments intact.

Docker Desktop and Colima store images, containers, volumes, and build cache in disk images that grow over time but rarely shrink on their own. Unused images from old projects, stopped containers, dangling volumes, and accumulated build cache layers can consume 10–30 GB. Colima additionally creates Lima VMs under ~/.colima and ~/.lima that can consume 5–20 GB each. CodeCleaner integrates with the Docker CLI to show exactly how much space images, containers, volumes, and build cache consume, and can prune them safely using official docker prune commands — not by deleting files directly. For Colima users, it also detects and measures the Lima VM disk footprint so you can reclaim space from unused VMs.

Android and Java developers accumulate significant disk usage from Gradle caches at ~/.gradle/caches, daemon files, wrapper distributions, and the Android build-cache. Android Virtual Device (AVD) images for testing on different screen sizes and API levels add several more gigabytes. Android Studio itself generates caches and logs under ~/Library/Caches/Google and ~/Library/Logs/Google that grow with every project. CodeCleaner detects your Android/Gradle installation, scans all of these locations, and lets you selectively clean caches, old daemon files, and unused wrapper distributions without affecting your current builds.

Beyond the major toolchains, CodeCleaner also handles Go module cache at ~/go/pkg/mod and build cache at ~/.cache/go-build, Ruby gem installations at ~/.gem plus rbenv and RVM paths, CocoaPods cache, Flutter's Dart pub cache at ~/.pub-cache, and Maven's local repository at ~/.m2/repository. Each of these grows silently over months of development. CodeCleaner's intelligent tool detection means it only scans for tools you actually have installed, so the scan stays fast and relevant regardless of how many languages you use.

Modern IDEs generate substantial cache data. VS Code stores extensions, workspace storage, and logs that can grow to several gigabytes. Cursor — the AI-powered code editor built on VS Code — creates its own separate cache, extensions, and workspace storage directories. JetBrains products like IntelliJ IDEA, WebStorm, PyCharm, and Android Studio each maintain their own caches and log directories under ~/Library. CodeCleaner detects all installed IDEs and shows you exactly how much cache, extension, workspace storage, and log data each one has accumulated, letting you clean them without affecting your settings or project configurations.

Every project on your Mac leaves behind build output folders — node_modules in JavaScript and TypeScript projects, target in Rust and Java, build and dist in various frameworks, .next in Next.js apps, .nuxt in Nuxt.js apps, .cache in bundler tools, and Python virtual environment folders like venv and .venv. CodeCleaner's Project Scanner walks your filesystem looking for project root markers (package.json, Cargo.toml, build.gradle, Xcode project files, etc.) and identifies all build artifact folders within each project. It ranks them by size with a "biggest offenders" list and lets you remove them in bulk. Since these folders are always regenerated by your build tool, deleting them is completely safe and can free tens of gigabytes.

Beyond caches and build artifacts, developers often accumulate large files — disk images, database dumps, video recordings, old archives, and VM snapshots — that are forgotten in project directories or Downloads. CodeCleaner's Large File Finder scans your accessible directories for files above a configurable threshold (default 100 MB) while smartly skipping dependency and build trees to avoid noise. The Duplicate File Detector uses CryptoKit hashing to find identical files larger than 1 MB, employing partial hashing for efficiency and extensive skip lists to ignore node_modules, caches, and .git directories. Together, these tools help you find wasted space that isn't related to any specific development tool.

Between Xcode caches (25–60 GB), Docker and Colima (10–30 GB), Node.js caches and node_modules (5–15 GB), Rust/Cargo (3–10 GB), Python environments (2–8 GB), Gradle/Android (5–12 GB), Go/Ruby/Flutter/Maven (2–8 GB), Homebrew (2–5 GB), IDE caches (2–5 GB), and system diagnostics (1–3 GB), a typical developer's Mac accumulates 50–150 GB of reclaimable space within a year. Generic disk cleaners like CleanMyMac or DaisyDisk don't understand developer toolchains — they miss DerivedData, ignore node_modules, can't identify stale simulator runtimes, and don't know how to prune Docker images or clean Cargo registries. CodeCleaner is purpose-built for developers. It understands the structure of Xcode projects, Node.js workspaces, Rust crates, Python environments, Gradle builds, Go modules, Homebrew downloads, Docker installations, and IDE data directories. Whether you are an iOS developer running low on disk space, a full-stack engineer with dozens of Node.js projects, or a polyglot developer using Rust, Python, and Go on the same machine, CodeCleaner finds and removes the developer junk that other tools overlook.

Safety is a core design principle of CodeCleaner. The app uses whitelist-based deletion — only paths on a known-safe list of cache and build artifact locations can be removed. Source code files are never targeted. Docker resources are cleaned via official docker prune CLI commands, not by deleting files directly. The node_modules scanner validates that directories actually end with node_modules before allowing removal. The Project Scanner only deletes recognized build artifact folder names (node_modules, target, build, dist, .next, .cache, etc.) or verified Python virtual environments. You always see a complete list of what will be deleted and can select or deselect individual items before any cleanup runs. Everything runs locally on your Mac — no data is uploaded, no account is required, and no telemetry is collected.