<div align="center"> <img src="crates/deepclean-app/icons/128x128@2x.png" alt="Void" width="96" height="96">

Void

Void cleans up after your AI agents — and your agents can call Void themselves.

Void finds and cleans developer disk bloat across 15 ecosystems: agent worktrees, agent transcripts, local AI models and the build artifacts behind them. One scan, gigabytes back. Everything runs locally.

Download · Website · Contributing · Changelog

<picture> <source media="(prefers-color-scheme: dark)" srcset="docs/shot-dark.png"> <img src="docs/shot-light.png" alt="Void's results screen: build artifacts grouped by ecosystem, each row showing its full path, age, size and risk level." width="900"> </picture> </div>

---

Why Void?

Every project you touch leaves something behind: a target/ here, a node_modules/ there, a Docker build cache quietly eating 20 GB. AI coding agents multiply that. Each parallel session gets its own git worktree with its own dependencies and build output, every conversation is saved as a transcript, and every model you tried is still sitting in ~/.ollama or the Hugging Face cache. You know it's there. You just don't know where, or which parts are safe to remove.

Void answers both questions. It walks your home directory in parallel, groups what it finds by ecosystem, tells you how stale each item is, and labels every cleanup action with a risk level before you click it. Nothing is deleted without your say-so. And because your agents are the ones filling the disk, they can ask Void for a plan themselves, from the command line or over MCP.

Highlights

• 15 ecosystem scanners: agent worktrees, AI agent data, local AI models, stale projects, Rust, Node.js, Python, Go, Java, Docker, Apple/Xcode, Homebrew, JetBrains, .NET and system caches
• Built for the AI era: worktrees from Claude Code, Cursor, Codex and Conductor, agent transcripts and editor state, Ollama and Hugging Face models, duplicate model files
• Agents can call Void: a void CLI with JSON output and dry-run plans, an MCP server, and Claude Code hooks
• Guard mode: watches free space in the background and warns before the disk fills up; optional auto-clean policies that only ever run Safe actions
• Safety first: blocked-path lists, sentinel-file detection, Safe / Caution / Danger on every action, Move to Trash for anything worth recovering
• Fast: multi-threaded filesystem walker with concurrent analysis, built on Tokio and the ignore crate
• Nothing runs unseen: every item shows the exact command or deletion it will perform
• Keeps a record: each clean is stored locally with the paths, commands and bytes recovered
• Local only: no account, no telemetry. Void never uploads anything. Its one network request is a once-a-day check of GitHub Releases for a newer version, which you can turn off in Settings → About (details)

Install

macOS

curl -fsSL https://raw.githubusercontent.com/eladbash/void/main/install.sh | sh

Downloads the latest .dmg for your architecture, installs to /Applications, and launches it.

Linux & Windows

Grab the installer for your platform from the Releases page: a .deb or .AppImage for Linux, an .msi or setup .exe for Windows.

Every release also lists each file's SHA-256 in SHA256SUMS (check a download with shasum -a 256 -c SHA256SUMS --ignore-missing), and in manifest.json, which is signed with Void's release key. The app checks that signature before it installs an update.

The desktop app is native on all three: a GPU-rendered GPUI window (Metal on macOS, DirectX on Windows, Vulkan on Linux), not a webview. On Linux the tray icon uses the StatusNotifierItem protocol, which GNOME shows with the AppIndicator extension and KDE shows natively.

The void CLI

The CLI (and the MCP server inside it) comes with the desktop app: it ships inside Void.app, next to Void.exe on Windows, and in /usr/bin with the .deb. Click Install void command on the Agents screen to put it on your PATH. On macOS that links it into /usr/local/bin (macOS asks for your password if the folder isn't writable) or ~/.local/bin; an AppImage copies it to ~/.local/bin; Windows adds the install folder to your PATH. The link follows the app through updates, and install.sh sets it up for you. Install hooks and MCP work right away, using the bundled copy.

Without the app, each release also attaches the CLI on its own for every platform (void-<version>-<target>); put it on your PATH as void. Or build it from source with Rust 1.95+ — the CLI needs no system libraries.

git clone https://github.com/eladbash/void.git
cd void
cargo install --path crates/void-cli    # builds and installs `void` into ~/.cargo/bin
void --version

~/.cargo/bin must be on your PATH (rustup adds it; if void is not found, add export PATH="$HOME/.cargo/bin:$PATH" to your shell profile). The desktop app prefers its bundled copy and falls back to the void on your PATH.

Then connect it to your agents:

void scan                           # see what's reclaimable (changes nothing)
claude mcp add void -- void mcp     # let Claude Code call Void as an MCP server
void mcp-config                     # JSON snippet for other MCP clients (Cursor, Codex…)
void hook install                   # optional: low-disk warning + worktree trim hooks

To update, run void self-update. A release binary replaces itself after checking the release's signature and checksum; a cargo-installed void prints the cargo install --force command to run instead. To remove: void hook uninstall (if you installed hooks), then cargo uninstall void-cli.

Desktop app from source

Requires Rust 1.95+. On Linux, install the windowing and font libraries first with ./scripts/linux-deps.sh (Debian/Ubuntu).

cargo run -p deepclean-app                  # run in development
cargo build --release -p deepclean-app      # release binary: target/release/void-app
cargo install cargo-packager --locked       # once
(cd crates/deepclean-app && cargo packager --release)   # .app/.dmg, .deb/.AppImage or .msi

How it works

1. Scan: Void walks your configured roots (your home directory by default) with a parallel walker, using half your cores and up to 8 concurrent analyses, and checks the well-known global locations (caches, agent data, model stores) directly.
2. Review: results are grouped by ecosystem with size, last-modified date, a risk level and the facts you need to decide: a worktree's branch and unpushed commits, a model's tag, which agent produced it.
3. Clean: each item carries its own actions (cargo clean, git worktree remove, docker builder prune, Move to Trash, delete), lowest risk first. Void re-checks the safety gates, runs it, and reports what it freed.

What Void finds

| Ecosystem | Artifacts | |-----------|-----------| | Agent worktrees | Git worktrees from Claude Code (<repo>/.claude/worktrees), Cursor (~/.cursor/worktrees), Codex (~/.codex/worktrees), Conductor (~/conductor/workspaces) and custom roots; orphaned worktrees; stale worktree records; merged agent branches | | AI agent data | Claude Code transcripts, file history, debug logs and caches; Codex sessions; Cursor / VS Code / Windsurf state databases and orphaned workspace storage | | Local AI models | Ollama models and orphaned blobs, Hugging Face cache (per repo, detached revisions, incomplete downloads), LM Studio, torch hub, ComfyUI; duplicate model files across stores | | Stale projects | Git projects with no commit and no edit in 90 days | | Rust | target/ dirs, cargo registry, git checkouts | | Node.js | node_modules/, npm / yarn / pnpm / Bun caches, Next.js / Turbo / Parcel / SvelteKit / Nuxt caches, Playwright and Puppeteer browsers | | Python | __pycache__/, virtualenvs, pip, uv and conda (Miniconda / Anaconda / Miniforge) caches, pytest / ruff / mypy / tox caches | | Go | Build cache, module cache, test cache | | Java | Gradle caches and build dirs, Maven .m2/repository and target/ dirs | | Docker | Dangling images, build cache (docker builder prune), stopped containers, unused volumes; Docker Desktop / OrbStack / Colima VM disk size (informational) | | Apple/Xcode | DerivedData, archives, device support, simulator caches and runtimes | | Homebrew | Package download cache | | JetBrains | Per-IDE caches (rebuilt on next launch) | | .NET | NuGet cache, bin/ and obj/ dirs | | System | Trash (macOS and Linux), application logs, stale downloads |

Built for the AI era

Agent worktrees

Agents that work in parallel give every task its own git worktree, and each one carries a full copy of node_modules/ or target/. Void finds them all and shows, for each: the agent that made it, the branch, uncommitted changes, unpushed commits, whether the branch is merged, and whether the worktree is locked.

• Trim build artifacts (keep worktree): the default action. Removes the rebuildable output inside an idle worktree and leaves your code and branch alone.
• Remove worktree: git worktree remove, offered only for clean worktrees. Void checks again that it is clean at the moment it runs, and never passes --force.
• Orphaned worktrees: directories whose repository no longer knows about them.
• Prune: git worktree prune for records that point at deleted directories.
• Merged agent branches: deleted with git branch -d, never -D, so git itself refuses anything that isn't merged.

AI agent data

Claude Code keeps every conversation in ~/.claude/projects, plus file-history snapshots, debug logs and caches. Codex keeps sessions and archived sessions. Void lists what's older than your retention window (30 days by default) and flags oversized session files.

AI editors (Cursor, VS Code, Windsurf) keep chat history in a state.vscdb SQLite database that grows without bound. Void offers to VACUUM it, never to delete it, because deleting it loses your chat history. Workspace storage for folders that no longer exist is offered as orphaned.

Void never touches agent settings, credentials, memory, CLAUDE.md, skills, agents, commands, plugins or your prompt history.

Local AI models

• Ollama: per model, with the space each one would actually free (layers shared between models are counted once), plus orphaned blobs no model references.
• Hugging Face: per repository, with detached revisions and incomplete downloads listed separately.
• LM Studio, torch hub, ComfyUI: per store.
• Duplicate models: the same weights downloaded into two stores. Void replaces the copies with APFS copy-on-write clones (hardlinks elsewhere), so the space comes back and every path still works. Nothing is deleted, and file contents are re-hashed right before replacement.

Usage by agent

The Agents screen adds it all up per tool, for example Claude Code: 38 GB — worktrees 30, transcripts 6, browsers 2, so you know which agent is costing you the most.

Project graveyard

Git projects with no commit and no edit in 90 days, with their remot