brew install --cask dreamofxm/diskwise/diskwise

Or from the Mac App Store (macOS 13+, free, auto-updated by the store):
DiskWise: Storage Cleaner

Prefer downloading a local file? Latest GitHub release —
every release ships the DMG's SHA-256.

Want to know what's actually safe to delete first? docs/safe-to-delete.md —
80 of the usual space hogs on macOS, each with what it is, what deleting it does and what it costs
if you were wrong. Generated from the same data the app reads at scan time (the tables are in
Chinese; Sources/DiskCleaner/Resources/safety_db.json is the machine-readable original).

What's new in v2.0

v2.0 is the biggest visual and interaction pass since the app shipped — same one-way delete path
and the same safety model, but almost everything you look at has been rebuilt.

• The ring is real material now. The band, its inner edge lights and the outer rim are layered
  crystal and glass with per-skin parameters, not flat colour fills. The six skins still change
  typeface, radius and motion — and now the ring's material too.
• A radar sweep while it measures. The scan light crosses the band once every 1.7 seconds: fast
  enough to read as measuring, not a slow decorative breathing.
• A first-run welcome, and a four-step guide. First launch explains "one ring = your whole
  disk" before a single number appears (the scan already runs behind it). A short four-page guide
  then shows how to act — the ring's centre and the two-tap gesture both changed, and guessing
  wrong means clicking the wrong thing.
• Hold Space to preview "after clearing everything". Press and hold to see the disk with every
  reclaimable spot gone; release and you're back. Nothing moves.
• By space / by cost. Flip the ledger between "what takes up room" and "what cleaning it costs"
  — four cost classes on the same denominator, so the rows add up to the disk.
• The first tap now says what will move. Arming a slice prints the exact count, the bytes and
  the first few folders the second tap will send to the Trash — no more guessing what "cache"
  covers. The two-tap gesture and the 3-second auto-cancel are unchanged.
• Reclaim you can watch. The bytes leave the tapped slice as droplets, cross the ring and land
  in the Trash tray; the ledger settles to the real count afterwards.
• Sound, only when you act. Every cue is synthesised in-app (no audio files, no network) and
  fires only on an interaction — no looping background bed. One visible toggle, remembered.
• A titlebar that holds together. The volume chip sits on the left, the controls on the right,
  and the scan-time Stop button no longer truncates when the window narrows.

Contents

• What's new in v2.0
• Quick start
• For AI agents
• Why this exists
• What you get
• Screenshots
• Install
• Build from source
• FAQ
• Known limits
• Roadmap
• Feedback
• Privacy
• License

Quick start

The GIF at the top of this page plays this exact order:

1. Open Overview — it walks the whole volume and draws the result as one ring, with the ledger
   beside it.
2. Click any row in that ledger — the folders under it unfold right there, and the ring steps back
   to a small reference dial.
3. Click the arc you can move twice: the first click arms it, the second moves it to the Trash.
   Undo puts it back, and emptying the Trash stays Finder's call.

For AI agents

The direct-download build ships a diskwise CLI (the App Store build doesn't), and it doubles as a
Model Context Protocol server — Claude Code, Cursor, Codex, Qoder,
OpenCode, Zed, ZCode and Claude Desktop can all reclaim disk space for you. It can't rm -rf: the only
removal path moves known-safe items to the Trash, every operation is undoable, and risky locations are
never touchable.

Put DiskWise in /Applications before copying this. The path below points at that copy; a build
left on the Desktop or run straight off the mounted DMG stops working the moment it moves or gets deleted.

Claude Code takes one line in Terminal:

claude mcp add diskwise -- "/Applications/DiskWise.app/Contents/MacOS/diskwise" mcp

Then just ask your agent "see what's worth cleaning on my Mac" — it scans, drafts a plan,
shows you the summary, and only moves anything after you agree. The eight above are the ones we
verified line by line; any client that can host a local stdio MCP server takes the same two values —
this binary's path, and the mcp argument. If one of them can't connect, that's on the client:
issues and PRs welcome. Details, snippets for the other seven
clients and the full safety model: docs/AGENTS-CLI.md.

Why this exists

A disk cleaner has to read a lot of your machine before it can tell you anything useful. Most of
them are closed-source, ship a background daemon, and treat rm -rf as a feature.

We go the other way:

The cache list explains each entry it can — what it is, what happens if you delete it, how it comes
back. We only write that text for entries we actually understand, so some rows carry it and some
don't. WeChat, DingTalk and WeCom are covered, because on many machines those three alone hold tens
of gigabytes.

It is built for machines that have been used by a developer for a few years — the ones where
node_modules, Docker volumes, Xcode DerivedData, and ten GB of caches quietly took over.

What you get

See the space

• Overview — the volume drawn as one ring: a slice is a block of bytes this pass actually
  measured, and the slices add up to the whole disk (top folders + everything else counted + not
  measured + purgeable + free).
  • The light band sits exactly on the edge of what's been measured so far.
  • A slice you can move away whole takes two taps: the first arms it, the second sends it to the
    Trash, and it lets go on its own after 3 seconds.
  • The button under the ring opens a list, not a delete: one row per spot it can take, each
    saying what removing it costs, with the harmless ones pre-ticked and the re-downloadable ones
    left for you to tick. The next screen repeats that list as a confirmation, and only its button
    moves anything — the result screen after it puts the whole batch back.
  • There is one list, the ledger beside the ring. Open a row and its detail unfolds right there —
    the folders under it, the places behind Other counted, the volumes behind Not measured.
  • While a row is open the ring steps back to a small reference dial, and Reveal and Dig in
    sit on that row.
• Whole-disk sweep — no scope to guess at. The open-source build walks the whole volume
  (whitelisted system roots included, other users' homes included); the sandboxed Mac App Store
  build walks everything its grant can reach and says so on screen.
  • Either way it covers the volume, not just the tidy corners of your home folder.
• A coverage line that names what it missed — the overview states how much of your used space it
  actually measured, and names the rest: system volumes, admin-only folders, and folders blocked on
  Full Disk Access.
  • The Grant access button only appears when a real read of a protected file says the permission
    is actually missing, so a machine that already granted it never gets nagged again.
  • Every number is decimal, so it matches Finder and About This Mac byte for byte.
• The "Other counted" slice adds up — open that row and every place behind the arc is listed
  under it, and the last line spells the total out part by part (the rows listed, plus the ones
  under the 100 MB floor), because "a hundred-plus GB, trust me" is not an explanation.
• Large Files — top N across the same roots, dev directories skippable.
• Long Untouched — files you haven't opened in N days, across the same roots.
• Duplicates — size → partial hash → full hash, grouped, the newest copy in each group locked
  so you can't nuke the only one.
  • Copies that live inside a venv / site-packages / DerivedData never enter the comparison and are
    listed separately: delete one and that environment is short a piece.

Dev machine specials

• node_modules — project sweep grouped per project, so you see "these 3 checkouts cost 4.7 GB".
• Docker Usage — one row per container runtime actually installed (Docker Desktop, OrbStack,
  Podman, colima), measured as what its virtual disk takes on this disk, with the engine's own
  figures listed under it. Read-only: it points at where to prune, it never deletes for you.

Clean up

• App Caches — a curated knowledge base (system caches, crash dumps, WeChat / DingTalk / WeCom /
  QQ …). Every entry explains what it is, what happens if you delete it, and how to get it
  back, with a badge saying what deleting costs — Safe, re-downloadable, or data loss.
• Dev Caches — the same knowledge base, the tools half of these machines actually fill the disk
  with: Homebrew, npm / pnpm / yarn, Maven, Gradle, conda, uv, cargo, Ollama models, Xcode archives,
  DerivedData and every simulator device listed one by one.
• Leftovers — data orphaned by apps you already uninstalled, matched against the bundle IDs of
  everything still installed. Under-reports rather than over-deletes.
• Trash — session stats, undo stack, and an Empty button: outside the sandbox it asks Finder
  to do the emptying, in the App Store build it opens the Trash so you can press ⌘⇧⌫.

Personalize

• Skins — 6 themes, and the interesting part is that they are not color swaps: each one changes
  typeface, corner radius, elevation, motion signature and chart palette. Morning Fog, Graphite,
  Mint, Polar Night, Aurora Glass, Ink & Paper — all six are in the box.
• Skins are data, not code — all six live in a single file,
  Sources/DiskCleaner/Resources/skins.json, which
  documents its own fields. A seventh theme is one JSON object: edit that file in the browser on
  GitHub and open a PR — no Xcode, no build, no Swift.

Screenshots

What the button under the ring opens — a list you tick, then a screen that repeats it back before
anything moves:

Reclaimable list	Confirm

Overview	Duplicates

Dev Caches	Leftovers

The skin store renders a live thumbnail of each theme — mini sidebar, ring gauge, rows and
buttons, all drawn with that skin's real tokens — so you can see the skeleton before you wear it:

Six skins, six skeletons. Same page, three of them — Graphite is the dark one:

Graphite	Mint	Polar Night

The UI ships in ten languages — English, Simplified and Traditional Chinese, Japanese, Korean,
German, Spanish, French, Russian and Brazilian Portuguese — switchable from the language menu on
the Skins page, and following the system language by default. Same screens in Chinese:

空间总览	开发缓存

Counts are inflected per language rather than pasted together in English: Russian picks its own form
for every number (1 файл, 3 файла, 11 групп), German and the Romance languages inflect
singular/plural, and Japanese and Korean use the measure word those languages actually use.

Install

Mac App Store

DiskWise: Storage Cleaner — macOS 13+, free, install it and
start using it; the store takes care of every version after that.

Each of those versions has to clear Apple's review first, so the store can trail a GitHub release. If
you want the newest build the moment it ships, use Homebrew or the DMG below.

Homebrew (one command)

brew install --cask dreamofxm/diskwise/diskwise

The fully-qualified name is what makes this work from a third-party tap: since Homebrew 6
non-official taps are untrusted by default, and installing by full name trusts just this
cask. If you would rather use the short name:

brew tap DreamOfXM/diskwise
brew trust --cask dreamofxm/diskwise/diskwise
brew install --cask diskwise

Tap details and how the pinned checksum gets bumped: DreamOfXM/homebrew-diskwise.

Homebrew installs the same file the Releases page carries. From v1.7 it is signed with a Developer ID
certificate and notarized by Apple, so it opens on a double-click and never reaches that step. Releases
before v1.7 were built ad-hoc, so macOS stops the first launch once and you approve it in
System Settings → Privacy & Security → Open Anyway (on macOS 13–14, right-click → Open does the
same job). Getting it from the Mac App Store skips that step entirely.

DMG

1. Download DiskWise-<version>[-universal].dmg from
   Releases.
2. Open it and drag DiskWise.app to Applications.
3. Double-click it. From v1.7 that just works — the app is Developer ID signed and notarized. On a
   pre-v1.7 build the first launch gets stopped once; approve it in System Settings → Privacy &
   Security → Open Anyway and the app opens normally from then on (on macOS 13–14, right-click → Open
   works instead; Sequoia removed that shortcut).

Releases built with ARCH=universal are named …-universal.dmg and carry both the Apple
Silicon and Intel slices in one file; the Apple Silicon-only ones are named DiskWise-<version>.dmg.
Checksums are published next to each release asset, and the cask pins the same SHA-256.

Build from source

You need the Xcode Command Line Tools — not full Xcode.

swift build                    # debug
swift run SelfTest             # all green is the precondition for shipping
swift run DiskCleaner          # run the app
bash build_app/build.sh        # localize check → build → self-test → .app → sign → dist/*.dmg + SHA256

build.sh refuses to produce a package if any of the three gates fails: missing translations, a
failing self-test, or an unpacked resource. The translation gate parses the Swift sources and
skins.json itself, so it catches a user-visible string that was never wrapped in L(…) as well as
a missing translation — a language can't silently ship half-translated.

Contributing? Start with CONTRIBUTING.md, then
docs/ARCHITECTURE.md and docs/DESIGN.md — both encode
rules that were learned the expensive way. Three PRs need no Swift at all: a
cache knowledge base entry, a
skin, or a translation.

FAQ

Is this a CleanMyMac alternative?
In the sense that it covers the same ground — caches, large files, duplicates, uninstall
leftovers, Docker usage — with the source on this page and no subscription. It deliberately
does less than a suite: no malware scan, no VPN, no mail cleanup, no "speed booster",
because those are different products with different risks.

Can it delete something I actually need?
Anything it removes lands in the Trash, and the session keeps an undo stack. Home itself and
~/Library can never be removed wholesale. Emptying the Trash is Finder's job, so macOS asks
you one more time before space is really gone.

Is it safe to delete node_modules, DerivedData, caches?
node_modules comes back with npm install, DerivedData with the next Xcode build, and
caches with the next run of the tool that wrote them. DiskWise states that per entry rather
than assuming you know it — each cache row says what it is, what happens if you delete it, and
how to get it back.

Does it send data anywhere?
No. No updater, no analytics, no account, no ads — the app has no network access at all, which
is also why feedback goes through GitHub or email below.

What about WeChat / DingTalk / WeCom caches?
They're in the cache knowledge base, because on a Chinese developer's Mac those are often the
single biggest consumers. That's why Simplified and Traditional Chinese are both first-class here
rather than a translation bolted onto an English UI.

Intel Mac?
From v1.3 on, every published DMG is built with ARCH=universal and carries both the arm64 and
x86_64 slices in one file, so the same download works on Apple Silicon and Intel. Releases before
v1.3 shipped an arm64-only file (DiskWise-<version>.dmg, no -universal in the name); Intel
users on those versions need to build from source instead (it takes a minute and needs no Xcode).
bash build_app/build.sh still defaults to Apple Silicon; pass ARCH=universal to get both.

Why does macOS complain on first launch?
From v1.7 it doesn't: every release from that version onward is signed with a Developer ID certificate
and notarized by Apple, so Gatekeeper lets it open. The ad-hoc builds before it get stopped once —
approve it in System Settings → Privacy & Security → Open Anyway and it launches normally
afterwards; on macOS 13–14 right-click → Open does the same job, a shortcut Sequoia removed. The App
Store build never gets stopped.

Known limits

• The system area is counted, not cleaned. Rows under /Library, /opt or /private come up
  with a System area badge and a locked checkbox: either only an admin can write there, or the
  files belong to Homebrew / Xcode, whose own cleanup commands do a better job.
• Large node_modules sweeps are slow and don't stream results yet.
• It will not find every orphan. Leftover detection is deliberately conservative.

Roadmap

• Streaming snapshots for slow scans
• More cache knowledge base entries (open a PR — this is the easiest way to contribute)

Feedback

The app has no network access, so there is no built-in "send feedback" button — pick a channel:

Email and issues also live in-app: the Feedback page at the bottom of the sidebar, with
copy buttons for every address.

If it cleared space you didn't know you had, starring the repo
is genuinely how the next person finds it — there is no marketing budget behind this project, so GitHub
search and awesome-list traffic are what decide whether anyone sees it at all.

Privacy

DiskWise has no network access and collects nothing — every scan runs locally on your Mac.
Full policy: docs/PRIVACY.md.

License

Apache License 2.0 — see LICENSE.