# Can Mole Analyze External Drives? Complete Guide to Scanning /Volumes

> Yes Mole analyzes external drives. Learn how to scan /Volumes with Mole by passing mount points to mo analyze, even though it skips them by default for faster startup.

- Repository: [Tw93/Mole](https://github.com/tw93/Mole)
- Tags: how-to-guide
- Published: 2026-03-20

---

**Yes, Mole can analyze external drives by passing the mount point (such as `/Volumes/MyUSB`) as an argument to the `mo analyze` command, though it deliberately skips them in default overview mode to maintain startup speed.**

Mole is a fast, terminal-based disk usage analyzer from the `tw93/Mole` repository that provides interactive TUI or JSON output for inspecting storage consumption. While the application defaults to an overview mode that focuses on internal system locations for rapid initialization, its scanning engine is fully capable of recursively analyzing any mounted filesystem, including external USB drives, network volumes, or SD cards attached to your system.

## How to Scan External Drives with Mole

To inspect external storage, you must explicitly provide the target path as a command-line argument. Mole treats external volumes exactly like standard directories once specified.

### Scan All Attached External Drives

Run the `mo analyze` command with `/Volumes` as the target to scan every currently mounted external drive on macOS:

```bash
mo analyze /Volumes

```

This initiates a recursive scan of the entire `/Volumes` directory, presenting an interactive tree view of all connected external storage devices.

### Target a Specific Drive

For focused analysis of a single external drive, pass the specific mount point:

```bash
mo analyze /Volumes/MyUSB

```

Replace `MyUSB` with the actual name of your mounted volume. Mole resolves this to an absolute path via `filepath.Abs()` and begins scanning immediately.

### Export JSON Reports for External Volumes

For automation or integration with external tools, use the `--json` flag to output structured data instead of the TUI:

```bash
mo analyze --json /Volumes/MyBackup > backup-report.json

```

This command scans `/Volumes/MyBackup` and redirects the JSON output to a file for further processing or archiving.

## Implementation Details in the Source Code

The ability to analyze external drives is implemented in the CLI entry point and scanning engine within the `cmd/analyze` package.

### Entry Point and Path Resolution

In [`cmd/analyze/main.go`](https://github.com/tw93/Mole/blob/main/cmd/analyze/main.go), the application determines the scan target through either the `MO_ANALYZE_PATH` environment variable or the first positional argument. Lines 34-46 handle the logic: if a target is provided, the code resolves it to an absolute path and sets `isOverview` to `false`, triggering a direct scan of that location regardless of whether it is internal or external storage.

```go
// Simplified excerpt from cmd/analyze/main.go
func main() {
    flag.Parse()

    target := os.Getenv("MO_ANALYZE_PATH")
    if target == "" && len(flag.Args()) > 0 {
        target = flag.Args()[0]          // ← user-supplied path, e.g. "/Volumes"
    }

    var abs string
    var isOverview bool
    if target == "" {
        isOverview = true                // default overview (skips /Volumes)
        abs = "/"
    } else {
        var err error
        abs, err = filepath.Abs(target) // resolve to absolute path
        if err != nil {
            fmt.Fprintf(os.Stderr, "cannot resolve %q: %v\n", target, err)
            os.Exit(1)
        }
        isOverview = false
    }

    if *jsonMode {
        runJSONMode(abs, isOverview)
    } else {
        runTUIMode(abs, isOverview)
    }
}

```

### Overview Mode vs. Targeted Scanning

When no path argument is provided, Mole initializes **overview mode** (lines 45-48), which limits the scan to predefined top-level locations such as Home, Applications, and System Library. This mode intentionally omits `/Volumes` to ensure the application starts instantly without waiting for potentially slow external drive spin-up or network volume latency.

However, when you supply a specific path—whether `/Volumes`, `/Volumes/ExternalSSD`, or any other mount point—Mole bypasses the overview restrictions and treats the target as a standard directory tree.

### The Scanning Engine

The actual filesystem traversal occurs in `scanPathConcurrent` and related helpers within the same package (lines 71-79 referenced in the view implementation). This engine walks the directory structure recursively using standard filesystem APIs, meaning it has no distinction between internal storage and externally mounted volumes. As implemented in `tw93/Mole`, the scanner reads directory entries, calculates sizes, and caches results uniformly for any valid path the operating system presents.

## Summary

- **Mole supports external drive analysis** via explicit path arguments to `mo analyze`.
- **Default overview mode skips `/Volumes`** to optimize startup performance.
- **Specify `/Volumes`** to scan all external drives, or use `/Volumes/DriveName` for specific targets.
- **JSON export** is available via `--json` flag for programmatic workflows.
- **Source implementation** in [`cmd/analyze/main.go`](https://github.com/tw93/Mole/blob/main/cmd/analyze/main.go) handles path resolution, while `scanPathConcurrent` performs the actual recursive scan.

## Frequently Asked Questions

### Does Mole automatically detect and scan external drives?

No. According to the source code in [`cmd/analyze/main.go`](https://github.com/tw93/Mole/blob/main/cmd/analyze/main.go), Mole’s default overview mode intentionally excludes `/Volumes` to ensure fast initialization. You must explicitly provide the external drive path as a command-line argument or via the `MO_ANALYZE_PATH` environment variable to trigger a scan.

### What path should I use to analyze external drives on macOS?

Use `/Volumes` as the target path to scan all mounted external drives, or `/Volumes/YourDriveName` to analyze a specific device. The [`README.md`](https://github.com/tw93/Mole/blob/main/README.md) explicitly documents this workflow, noting that these paths resolve to standard mount points where macOS attaches external storage.

### Can I analyze multiple external drives simultaneously?

Yes. Running `mo analyze /Volumes` scans every subdirectory within `/Volumes`, effectively analyzing all currently attached external drives in a single operation. The TUI will display the combined directory tree, or you can export JSON for aggregated analysis.

### Is there a performance difference when scanning external versus internal drives?

The scanning logic itself (`scanPathConcurrent`) treats all paths identically. However, the default overview mode skips external locations specifically to avoid the latency associated with spinning up external HDDs or connecting to network volumes. Once you explicitly target an external drive, the scan proceeds at the speed of the underlying connection protocol (USB, Thunderbolt, etc.).