# What Go Modules Are Used in Mole? Complete Dependency Analysis

> Discover the five core Go modules powering Mole: Bubble Tea and Lipgloss for UI, xxhash for hashing, gopsutil for system stats, and x/sync for concurrency. Understand Mole's dependencies.

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

---

**Mole relies on five direct Go modules—Bubble Tea, Lipgloss, xxhash, gopsutil, and golang.org/x/sync—to render its terminal UI, hash metric snapshots, and collect system statistics across platforms.**

Mole is a Go-based CLI system monitor developed by tw93 that combines rich terminal interfaces with real-time hardware metrics. The specific Go modules used in Mole are declared in the `require` block starting at line 5 of the project's [`go.mod`](https://github.com/tw93/Mole/blob/main/go.mod) file. These dependencies power everything from the interactive `mo status` view to the cross-platform collection of CPU, memory, and GPU statistics.

## Primary Go Modules in Mole

Mole’s core functionality depends on five direct dependencies defined in `go.mod`. These modules handle the user interface, system metrics, caching, and concurrency orchestration.

### Terminal UI Framework (bubbletea and lipgloss)

**`github.com/charmbracelet/bubbletea`** at version `v1.3.10` provides the TUI (terminal UI) framework that drives the interactive `mo status` view. It implements the Elm architecture pattern for Go, handling user input, updates, and rendering loops.

**`github.com/charmbracelet/lipgloss`** at version `v1.1.0` supplies the styling primitives used to render colored boxes, headers, and the optional ASCII cat animation. It works alongside Bubble Tea to apply margins, padding, and color profiles.

In [`cmd/status/main.go`](https://github.com/tw93/Mole/blob/main/cmd/status/main.go), these modules are imported directly to initialize the program:

```go
import (
    tea "github.com/charmbracelet/bubbletea"
    "github.com/charmbracelet/lipgloss"
)

```

This import block appears at lines 13–15 of the entry point, which defines `runTUIMode` and the `newModel()` constructor used to launch the interface.

### System Metrics Collection (gopsutil)

**`github.com/shirou/gopsutil/v4`** at version `v4.26.2` is the cross-platform system-information library responsible for gathering CPU, memory, disk, network, battery, and GPU statistics. It abstracts OS-specific APIs into a unified Go interface, enabling Mole to monitor hardware on Linux, macOS, and Windows without platform-specific code.

The collector implementation (typically located in the internal collector package) uses this module to populate the `MetricsSnapshot` struct consumed by both the UI and the JSON output mode (`runJSONMode`).

### Caching and Concurrency (xxhash and x/sync)

**`github.com/cespare/xxhash/v2`** at version `v2.3.0` provides fast non-cryptographic hashing used by the collector for caching metric snapshots. It generates cache keys quickly without the overhead of cryptographic algorithms.

**`golang.org/x/sync`** at version `v0.20.0` supplies concurrency primitives such as `errgroup`, which Mole uses throughout its collector pipelines to manage goroutines and aggregate errors from multiple system probes.

## Indirect Dependencies

Beyond the five direct modules, Mole pulls in numerous transitive dependencies marked as `// indirect` in `go.mod` (lines 13–41). These are automatically fetched by the Go toolchain to satisfy the requirements of the primary libraries.

Key indirect modules include:

- **`github.com/charmbracelet/colorprofile`** (`v0.4.1`) — Color handling for Lipgloss
- **`github.com/charmbracelet/x/ansi`** (`v0.11.4`) — ANSI escape-code utilities
- **`github.com/charmbracelet/x/term`** (`v0.2.2`) — Terminal size and input handling
- **`github.com/muesli/termenv`** (`v0.16.0`) — Advanced terminal rendering capabilities
- **`github.com/tklauser/go-sysconf`** (`v0.3.16`) — System configuration queries supporting gopsutil
- **`golang.org/x/sys`** (`v0.41.0`) — Low-level OS interaction required by gopsutil

These modules form the underlying infrastructure that enables the TUI to render correctly across different terminal emulators and operating systems.

## How Mole Implements These Modules

The architecture separates concerns into distinct layers: the UI layer uses Bubble Tea and Lipgloss, while the metrics layer relies on gopsutil and x/sync.

### Bubble Tea Model Pattern

The following pattern mirrors the implementation in `runTUIMode` (lines 51–55 of [`cmd/status/main.go`](https://github.com/tw93/Mole/blob/main/cmd/status/main.go)), where `newModel()` creates a Bubble Tea program:

```go
package main

import (
    tea "github.com/charmbracelet/bubbletea"
    "fmt"
)

type model struct{}

func (m model) Init() tea.Cmd { return nil }
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        if msg.String() == "q" {
            return m, tea.Quit
        }
    }
    return m, nil
}
func (m model) View() string { return "Press q to quit" }

func main() {
    p := tea.NewProgram(model{})
    if _, err := p.Run(); err != nil {
        fmt.Println("error:", err)
    }
}

```

### Gathering System Metrics with gopsutil

Mole’s collector uses the same `gopsutil/v4/cpu` package shown below to fill `MetricsSnapshot.CPU.Usage`:

```go
package main

import (
    "fmt"
    "github.com/shirou/gopsutil/v4/cpu"
    "time"
)

func main() {
    percent, _ := cpu.Percent(time.Second, false)
    fmt.Printf("CPU usage: %.2f%%\n", percent[0])
}

```

### Styling Headers with Lipgloss

The `renderHeader` function in [`cmd/status/view.go`](https://github.com/tw93/Mole/blob/main/cmd/status/view.go) applies Lipgloss styles similar to this example:

```go
package main

import (
    "github.com/charmbracelet/lipgloss"
    "fmt"
)

func main() {
    style := lipgloss.NewStyle().
        Bold(true).
        Foreground(lipgloss.Color("#FAFAFA")).
        Background(lipgloss.Color("#7D56F4")).
        Padding(0, 2)

    fmt.Println(style.Render("Mole – System Monitor"))
}

```

## Summary

- **Mole uses five direct Go modules**: Bubble Tea (`v1.3.10`), Lipgloss (`v1.1.0`), xxhash (`v2.3.0`), gopsutil (`v4.26.2`), and golang.org/x/sync (`v0.20.0`).
- **All dependencies are declared** in the `require` block of `go.mod` starting at line 5.
- **Bubble Tea and Lipgloss** power the `mo status` TUI implemented in [`cmd/status/main.go`](https://github.com/tw93/Mole/blob/main/cmd/status/main.go).
- **gopsutil** provides cross-platform system metrics collection for CPU, memory, disk, and hardware sensors.
- **xxhash** enables fast caching of metric snapshots, while **x/sync** manages concurrency in collector pipelines.
- **Indirect dependencies** (lines 13–41 of `go.mod`) include terminal handling libraries like `termenv` and `colorprofile`.

## Frequently Asked Questions

### What is the main UI framework used in Mole?

Mole uses **Bubble Tea** (`github.com/charmbracelet/bubbletea` v1.3.10) as its primary TUI framework. It implements the Elm architecture to handle user input, state updates, and rendering in the `mo status` command. The styling is handled by **Lipgloss** (`v1.1.0`), which provides the color profiles and layout primitives visible in the interface.

### How does Mole collect system metrics on different operating systems?

Mole delegates all system information gathering to **gopsutil/v4** (`v4.26.2`). This module abstracts platform-specific APIs for Linux, macOS, and Windows into a single Go interface, allowing Mole to retrieve CPU usage, memory statistics, disk I/O, network interfaces, battery status, and GPU information without writing OS-specific code.

### Why does Mole use xxhash for caching?

Mole imports **xxhash/v2** (`v2.3.0`) to generate fast, non-cryptographic hash keys for caching metric snapshots. Because xxhash is optimized for speed rather than cryptographic security, it minimizes CPU overhead when the collector checks or stores cached system states between updates.

### Where are all the Go modules declared in the Mole repository?

All Go modules used in Mole are declared in the **[`go.mod`](https://github.com/tw93/Mole/blob/main/go.mod)** file at the repository root. Direct dependencies appear in the `require` block starting at line 5, while transitive indirect dependencies are listed below (lines 13–41) with the `// indirect` comment.