GetInfo

See where your disk space actually went.

A native macOS disk-space visualizer that draws every file on your drive as a nested, squarified treemap — inspired by the legendary SpaceMonger of yore, rebuilt from scratch in SwiftUI.

---

    ┌─────────────────────────┬───────────────┬───────┐
    │                         │               │       │
    │    /Users/you/Movies    │    Library    │  bin  │
    │         12.4 GB         │     6.1 GB    │ 820MB │
    │  ┌──────────┬─────────┐ │ ┌───┬───┬───┐ │       │
    │  │  4K vid  │ archive │ │ │ A │ B │ C │ ├───────┤
    │  │   8.2GB  │  3.1GB  │ │ ├───┴───┴───┤ │ /etc  │
    │  ├──────────┴─────┬───┤ │ │  Caches   │ │ 12 MB │
    │  │   raw photos   │ … │ │ │   2.4 GB  │ │       │
    │  └────────────────┴───┘ │ └───────────┘ │       │
    └─────────────────────────┴───────────────┴───────┘

Why?

Disk usage utilities tell you a folder is "big." GetInfo shows you why — at a glance — by allocating screen real-estate proportional to file size and nesting directories visually. The largest files are the largest rectangles. That's it. That's the whole pitch.

Features

• Squarified treemap — uses Bruls et al.'s algorithm for near-square rectangles, so labels stay readable and proportions feel natural.
• Recursive nested rendering — directories show as colored frames with header bars, with their children drawn inside them up to 6 levels deep.
• Click to drill down — tap any folder to zoom in; breadcrumbs and a back button let you climb back out.
• Async scanning — the file enumerator runs off the main thread so the UI never freezes, even on multi-million-file home directories.
• Depth-aware coloring — hue spreads across siblings, brightness dims with depth, so you can read structure at a glance.
• Universal binary — single build runs natively on Apple Silicon and Intel.
• Zero telemetry, zero network — it reads files, draws rectangles, and goes home.

Install

Homebrew (recommended)

brew install --cask just-an-oldsalt/tap/getinfo

The cask in this repo points at GitHub Releases. If you're tapping directly, publish a release tagged v1.0 first — see Releasing below.

Manual

1. Grab the latest .dmg from the Releases page.
2. Open it, drag GetInfo to Applications.
3. First launch: right-click → Open (unsigned build, until code-signing lands).

Build from source

You'll need Xcode 16+ and macOS 15 (Sequoia) or later.

git clone https://github.com/just-an-oldsalt/GetInfo.git
cd GetInfo

# Build a Release universal binary
make build

# Or build + DMG + ZIP in one shot
make release

# Drop the app into /Applications
make install

Common targets:

Target	What it does
make build	Universal Release build via xcodebuild
make dmg	Wraps the .app into a drag-to-Applications DMG
make zip	Zips the .app (handy for Homebrew cask artifacts)
make install	Copies the build into /Applications
make sha256	Prints the DMG checksum for the cask
make clean	Nukes build/ and release/

How it works

┌────────────────────┐    ┌────────────────────┐    ┌─────────────────────┐
│   GetInfoApp       │ ─▶ │   ContentView      │ ─▶ │   TreemapView       │
│   (SwiftUI Scene)  │    │   (toolbar + nav)  │    │   (GeometryReader)  │
└────────────────────┘    └─────────┬──────────┘    └──────────┬──────────┘
                                    │                           │
                                    ▼                           ▼
                          ┌────────────────────┐    ┌─────────────────────┐
                          │   DiskScanner      │    │   TreemapLayout     │
                          │   FileManager      │    │   squarify(...)     │
                          │   enumerator       │    │   Bruls et al. '00  │
                          └────────────────────┘    └─────────────────────┘

• FileNode.swift — the in-memory tree. DiskScanner.scan walks the directory with FileManager.enumerator, builds a flat path → node map, reattaches children to parents, then bubbles sizes up bottom-up and sorts by size descending at every level.
• TreemapLayout.swift — the squarified algorithm. It greedily packs the largest remaining items into a strip, choosing the strip orientation (horizontal vs. vertical) that minimizes the worst aspect ratio.
• TreemapView.swift — RecursiveCell renders one node, then asks the layout engine to lay out its children inside the leftover space. Hue spreads around the parent's hue; brightness decays with depth.
• ContentView.swift — toolbar, breadcrumbs, scan progress, and click routing for drill-down navigation.

Project layout

GetInfo/
├── GetInfo/                  # SwiftUI app source
│   ├── GetInfoApp.swift      # @main entry point
│   ├── ContentView.swift     # toolbar + navigation + scan kickoff
│   ├── FileNode.swift        # tree model + DiskScanner
│   ├── TreemapLayout.swift   # squarified treemap algorithm
│   └── TreemapView.swift     # recursive renderer
├── GetInfoTests/             # unit tests
├── GetInfoUITests/           # UI tests
├── Casks/getinfo.rb          # Homebrew cask manifest
├── scripts/release.sh        # build + package + checksum helper
└── Makefile                  # build / dmg / zip / install targets

Releasing

# Bump version, build everything, print SHA256s
./scripts/release.sh 1.1.0

# Tag and push
git tag -a v1.1.0 -m "Release v1.1.0"
git push origin v1.1.0

Then attach release/GetInfo-1.1.0.dmg (and .zip) to the GitHub release, and update Casks/getinfo.rb with the new version and DMG SHA256.

Roadmap

• Code signing + notarization for friction-free first launch
• Persistent scan cache so re-opening the same folder is instant
• Right-click → Reveal in Finder / Move to Trash
• File-type heatmap mode (color by extension instead of hue order)
• CLI companion that emits the same tree as JSON

Credits

Inspired by SpaceMonger (Werkema, late 90s — still the gold standard) and the squarified-treemap paper by Bruls, Huijsen and van Wijk (2000).