How to Free Up Disk Space as a Developer: Clear Hugging Face, npm, conda, and Docker Caches

If you write code — and especially if you work with machine learning — your disk
is quietly filling up with data you downloaded once and forgot about. A model
you tried for an afternoon. Package caches from five virtualenvs. Docker images
from a project you finished months ago. This guide covers where that space
goes, how to reclaim it manually, and how to do it all from one place.

Where a developer's disk space actually goes

The biggest offenders almost never show up in Finder or Explorer, because
they're hidden in cache directories:

Machine learning model caches

These are the heavyweights. A single large language model can be several
gigabytes, and most people accumulate dozens.

• Hugging Face — ~/.cache/huggingface
• Ollama — ~/.ollama/models
• PyTorch hub — ~/.cache/torch
• Whisper — ~/.cache/whisper

To clear the Hugging Face cache manually:

rm -rf ~/.cache/huggingface/hub

The catch: this deletes every model, including the ones you actually use.
They'll re-download on demand, but that's a lot of bandwidth if you only wanted
to remove one abandoned model.

Package manager caches

Every language ecosystem keeps a cache to speed up reinstalls. They regenerate
automatically, so they're safe to clear:

npm cache clean --force            # ~/.npm/_cacache
pip cache purge                    # pip download cache
conda clean --all                  # conda packages and tarballs
cargo cache --autoclean            # Rust crate registry (needs cargo-cache)
go clean -cache                    # Go build cache
docker system prune -a             # dangling images, containers, build cache

Build artifacts and IDE caches

• Xcode DerivedData — ~/Library/Developer/Xcode/DerivedData (can hit tens of GB)
• Gradle — ~/.gradle/caches
• JetBrains IDEs — ~/Library/Caches/JetBrains
• node_modules in dead projects — often gigabytes each

The stuff manual commands miss

Two categories that no clean command touches:

• Duplicated Python packages. Install torch in eight virtualenvs and you have eight copies — often 2–3 GB each.
• App leftovers. Uninstalling an app on macOS usually leaves its Application Support, Caches, and Preferences behind forever.

The problem with cleaning it manually

Running these commands works, but it has real downsides:

1. You have to remember every location across every tool you use.
2. rm -rf on a cache is all or nothing — you can't keep the models you use.
3. You can't easily see what's actually taking up space before deleting.
4. It's different on Windows, where the paths change (%LOCALAPPDATA%\pip\Cache, the registry-based uninstaller, etc.).

Doing it all from one place: Jharu

Jharu is a free, open-source disk cleaner built
specifically for this problem. It runs on macOS and Windows and understands the
developer and AI locations above — but instead of blunt deletion, it tells you
what each thing is and whether you've used it.

Per-model ML cleanup. Jharu lists every Hugging Face, Ollama, PyTorch, and
Whisper model individually, with its size and — crucially — whether you've
actually loaded it since downloading. So you can reclaim the 6 GB model you
tried once without touching the ones you use daily. Shared Ollama layers are
preserved, so removing one model never breaks another.

Deep cache scan. It scans 25+ known locations (npm, pip, uv, yarn, pnpm,
conda, Cargo, Go, Gradle, Maven, NuGet, Docker, Xcode, JetBrains, Playwright,
and more), each rated safe to clear, re-downloadable, or review first.

Python environment analyzer. It finds every virtualenv and conda
environment and quantifies duplication across them — the "torch is installed
eleven times" problem, in one view.

A treemap of your whole disk. See every folder sized by what it holds, so
the biggest space-eater is literally the biggest block. Click to drill in.

Clean uninstaller. Removes an app and the leftovers it scattered across
your system.

Safe by design

• Nothing is ever permanently deleted — everything goes to the Trash or Recycle Bin, and a dialog tells you the real consequence first.
• No telemetry, no tracking, no subscription.
• No registry "cleaner" (it doesn't work), and if Jharu can't read a folder it says so instead of silently hiding it.

Get it

Jharu is free and open source under Apache 2.0.

• Download: jharu.matily.org (macOS Apple Silicon + Intel, and Windows 64-bit)
• Source: github.com/riponcm/Jharu

Run one scan and you'll usually find tens of gigabytes you didn't know were
there. If you reclaim some space, drop a comment with how much.