Where did the disk space go?

Index a filesystem once. Then walk it in a browser. Area is allocated bytes, so the biggest folder is the biggest block.

Read-only by design. GPL-3.0-or-later.

Sample snapshot
Path /
Allocated 670.6 GB
Items 7.4M
var 312.4 GB
home 188.4 GB
srv 61.2 GB
usr 44.8 GB
opt 32.6 GB
data 18.4 GB
other 12.8 GB
  • System
  • Home
  • Data
  • Other
Open a block to drill in.
A working map of a sample snapshot. The client uses the same rule: area is allocated bytes.

  • O(1) folder sizes one column read
  • O(depth) scan memory streams to disk
  • 0 telemetry calls offline by default

Area is bytes.
Nothing else.

A folder twice the size gets twice the area. No pie charts that flatter small folders, no top-ten list that hides the long tail.

The map is the index, drawn. Read a block at rest, or open it and keep walking. The numbers never leave the tree.

Scan once. Then stop waiting.

The scanner is a stream. The index is a set of flat files. Queries are reads, not crawls.

  1. Scan

    The scanner walks the tree in pre-order and streams node records to disk. Memory tracks depth, not the number of files. Hardlinked files are counted once.

    $ mish scan /var --json
    
    pre-order nodes
    hardlink dedup
    sparse + mount flags
    O(depth) memory
  2. Index

    A snapshot is four flat files: a manifest, fixed-size node records, concatenated names, and a subtree-size column. Folder totals are one read, not a recursive query.

    snapshots/8f2c/
      manifest.json
      nodes.bin
      names.bin
      subtree.bin
  3. Explore

    The daemon serves depth-limited tiles over a Unix socket. The browser receives the rectangles it can draw, never fifty million rows. Every command and endpoint is JSON.

    browser
      → REST / SSE
      → daemon (UDS)
      → mmap
    
    JSON in, JSON out

The same snapshot, read six ways.

Every view is coupled to the same selection. Change the scope in one and the others follow. No view reloads the tree.

Sample snapshot, 670.6 GB

Area is allocated bytes. Click a block to drill in; breadcrumbs walk back out.

Web UI guide

Also in the client: histogram, extension, age and owner breakdowns, duplicate candidates, and snapshot diff.

The biggest folders are inside containers.

mish reads container, image and volume sizes from the Docker Engine API and maps mounts onto the snapshot. A volume stops being a mystery number in the treemap.

The socket is GET-only, through a proxy. The app never gets write access to Docker, and the Docker views report unavailable when there is no socket. Everything else keeps working.

Containers Sample
postgres postgres:16
42.6 GB
pgdata → /var/lib/postgresql/data
CPU 2.4% MEM 412 MB
api app:1.4
18.2 GB
uploads → /app/uploads
CPU 8.1% MEM 1.2 GB
worker app:1.4
9.4 GB
none
CPU 1.2% MEM 640 MB
redis redis:7
3.1 GB
redisdata → /data
CPU 0.4% MEM 96 MB

Three commands. Then open the map.

The compose file builds the Rust core, the API and the web client, mounts the host read-only, and starts a GET-only Docker proxy.

OS
Linux. The portable scanner builds on macOS and Windows.
Runtime
Docker Engine with Compose v2.
Access
Root or CAP_DAC_READ_SEARCH for a full filesystem scan.

Open localhost:9543 and press Scan. Start with /var or /home; a full / scan takes as long as the disk does.

Terminal
git clone https://github.com/Roobyx/mishcd mishdocker compose up -d --build

What it will not do.

  • Read-only

    No delete, move or edit. The only writes go to its own data directory.

  • No telemetry

    No external calls at runtime. It works with the network unplugged.

  • GET-only Docker

    The app talks to a socket proxy that allows GET. It never gets write access.

  • Validated paths

    API paths are checked against the indexed roots. Traversal outside them is rejected.

No authentication in v1. Bind localhost or put it behind TLS.

Security details

Questions operators ask.

Short answers here. The docs carry the long ones, including permissions and failure modes.

Troubleshooting
Does mish change anything on the disk?

No. It never deletes, moves or edits scanned files, and v1 exposes no destructive operation. Snapshots are written to its own data directory and nowhere else.

How much memory does a scan use?

The scanner streams nodes to disk with state proportional to depth, not file count. The design budget is under 512 MB at 50 million files, and under 1 GB for the full stack. Measure your own tree before a 50M-file run.

Do I need root?

For a full filesystem scan, yes, or CAP_DAC_READ_SEARCH. Mounting a narrower path read-only works without broad access.

What happens with rootless Docker or Podman?

The Docker views report unavailable. The scanner, the index and every other view keep working. Docker is optional.

Is there authentication?

Not in v1. Bind it to localhost or put it behind a reverse proxy with TLS. Do not expose port 9543 directly to the internet.

Which platforms are supported?

Linux is the primary target and has the fast path. The portable scanner builds on macOS and Windows; the Linux path is what is tuned.

How do I update?

Run git pull, then docker compose up -d --build. Snapshots stay in the mish-data volume.

Can I query it from scripts?

Yes. Every CLI command emits JSON with --json, and the daemon exposes a versioned JSON-RPC socket. The REST API mirrors it for the web client.