Self-Hosted Terminal Dashboard: Best System Monitoring Tools 2026

When you manage self-hosted infrastructure, knowing what your servers are doing in real time isn’t optional — it’s essential. While full-stack monitoring platforms like prometheus, Grafana, and Zabbix excel at long-term metrics collection and alerting, there are moments when you need an immediate, at-a-glance view of system health directly in your terminal. No web interface to load, no API keys to configure, no dashboards to build. Just SSH into a machine and see everything that matters.

This guide compares the three best open-source terminal dashboards for system monitoring in 2026: btop, glances, and bottom. Each takes a different approach to presenting CPU, memory, disk, network, and process data, and the right choice depends on your workflow and environment.

Why Self-Hosted Terminal Monitoring Matters

Cloud-based monitoring services are convenient, but they introduce dependencies you may not want in a self-hosted stack:

• No external dependency — Your monitoring works even when the internet is down. If your server loses connectivity, you can still diagnose problems locally or through an out-of-band console.
• Zero data leakage — System metrics never leave your network. For privacy-conscious setups or compliance-restricted environments, this is a hard requirement.
• Immediate access — No browser tabs, no login screens, no JavaScript-heavy SPAs. A single command gives you a live view of every resource.
• Low resource overhead — Terminal dashboards use a fraction of the RAM and CPU that browser-based dashboards consume. On resource-constrained servers (VPS, edge devices, Raspberry Pi clusters), that difference is meaningful.
• SSH-friendly — Works over any SSH connection, even slow or high-latency links. No need to open additional ports or configure reverse proxies.

For homelab operators, sysadmins, and developers running self-hosted services, terminal dashboards fill the gap between top (too basic) and full observability stacks (too heavy for quick checks).

What Makes a Good Terminal Dashboard in 2026

A modern terminal monitoring tool should deliver:

• Real-time metrics — CPU usage per core, memory breakdown, disk I/O, network throughput, and GPU utilization where available.
• Process management — View, sort, filter, and kill processes without leaving the interface.
• Historical graphs — Rolling sparkline or bar graphs that show trends over the last few minutes, not just instantaneous values.
• Theming and customization — Because you’ll be staring at this screen a lot. Color accuracy, layout flexibility, and font compatibility matter.
• Low resource footprint — The tool should not become the problem it’s trying to diagnose.
• Cross-platform support — Linux is primary, but macOS and WSL compatibility is expected.

btop: The Visual Powerhouse

btop is the most visually polished terminal monitor available today. A C++ rewrite of the Python-based bashtop and bpytop, it delivers a stunning, fully interactive UI with mouse support, theming, and extensive configuration options.

Key Features

• Per-core CPU usage with detailed graphs and load average history
• Memory, swap, and available RAM with color-coded bars
• Disk I/O with read/write throughput graphs per mounted filesystem
• Network throughput with upload/download graphs and total transfer counters
• GPU monitoring (NVIDIA, AMD, Intel) with temperature and utilization
• Interactive process list with tree view, sorting, filtering, and signal sending
• Full mouse support for clicking between tabs, selecting processes, and adjusting settings
• 20+ built-in color themes with the ability to create custom ones
• Configuration file (~/.config/btop/btop.conf) for persistent settings
• Supports TTY width as narrow as 80 columns, scales up to 4K terminals

Installation

Ubuntu/Debian:

1

sudo apt install btop

Arch Linux:

1

sudo pacman -S btop

macOS (Homebrew):

1

brew install btop

From source:

1
2
3
4

git clone https://github.com/aristocratos/btop.git
cd btop
make
sudo make install

docker Container

Run btop inside a container to monitor the host system via shared /proc:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# docker-compose.yml
version: "3.8"
services:
  btop:
    image: alpine:latest
    container_name: btop
    restart: unless-stopped
    volumes:
      - /proc:/proc:ro
      - /sys:/sys:ro
    command: >
      sh -c "
        apk add --no-cache btop ncurses-terminfo &&
        btop --utf-force
      "
    environment:
      - TERM=xterm-256color
    tty: true
    stdin_open: true

Start it with docker compose up -d and attach with docker attach btop.

Configuration Tips

1
2
3
4
5
6
7
8

# ~/.config/btop/btop.conf
color_theme="dracula"
update_ms=1000
temp_sensor=auto
proc_tree=true
proc_sorting="cpu direct"
net_download="auto"
net_upload="auto"

btop’s update_ms controls the refresh rate. The default of 1000ms is fine for most uses, but you can lower it to 500ms for more responsive updates on powerful machines — or raise it to 2000ms to reduce CPU overhead on constrained hardware.

Glances: The All-in-One Monitoring Swiss Army Knife

Glances takes a different approach. Rather than focusing purely on interactivity, it provides broad coverage of system metrics and, crucially, can export data to external systems — making it a bridge between terminal monitoring and centralized observability.

Key Features

• CPU, memory, swap, load, network, and disk I/O monitoring
• File system usage with mount point details and I/O counters
• Docker container monitoring — see container-level resource usage inline
• Sensor data: temperatures, fan speeds, battery levels
• RAID array status and SMART disk health
• Process list with CPU and memory sorting
• Export plugins — send metrabbitmqInfluxDB, Prometheus, Elasticsearch, StatsD, RabbitMQ, CSV, JSON, REST API, and more
• Web server mode — serve a browser-based dashboard on a configurable port
• Alert system with configurable thresholds and color coding
• Client/server mode — monitor multiple remote servers from a single glances instance
• Python-based, making it easy to extend with custom plugins
• SNMP support for monitoring network equipment

Installation

Via pip (recommended for latest version):

1

pip install glances

Ubuntu/Debian:

1

sudo apt install glances

macOS (Homebrew):

1

brew install glances

Install with all extras (Docker, web, export plugins):

1

pip install glances[action,browser,cloud,cpuinfo,docker,folders,gpu,graph,ip,raid,snmp,web,wifi]

Docker Container

Glances runs beautifully in Docker and can monitor the host via volume mounts:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# docker-compose.yml
version: "3.8"
services:
  glances:
    image: nicolargo/glances:latest-full
    container_name: glances
    restart: unless-stopped
    pid: host
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /run/user/1000/podman/podman.sock:/run/user/1000/podman/podman.sock:ro
    environment:
      - GLANCES_OPT=-w
    ports:
      - "61208:61208"

The -w flag starts the web server mode. Access the dashboard at http://your-server:61208. For terminal-only mode, remove the ports section and the GLANCES_OPT environment variable.

Server/Client Mode for Multi-Host Monitoring

Glances can run as a server on each machine and be monitored from a central client:

1
2
3
4
5
6

# On each monitored server:
glances -s --password

# On the monitoring station:
glances -c 192.168.1.10  # Single server
glances                    # Interactive browser to discover servers

Exporting to Prometheus

One of glances’ killer features is the ability to act as a Prometheus exporter without any additional tooling:

1
2
3
4
5

# Start glances as a Prometheus exporter
glances --export prometheus --export-prometheus-prefix glances_

# The metrics are now available at:
curl http://localhost:61208/metrics

This means you can get Prometheus-compatible metrics from any server running glances, without deploying node_exporter or configuring additional exporters.

Bottom: The Minimalist, Cross-Platform Choice

Bottom (btm) is a Rust-based system monitor that prioritizes simplicity, performance, and cross-platform consistency. It’s the lightest of the three tools and runs identically on Linux, macOS, and Windows.

Key Features

• CPU usage with per-core breakdown and average graph
• Memory and swap usage with graphical representation
• Network usage with upload/download graphs
• Disk usage and I/O per mounted filesystem
• Process list with sorting, searching, and kill functionality
• Temperature sensors (Linux, macOS)
• Highly configurable layout — widgets can be rearranged, resized, and toggled
• Battery widget for laptops
• Customizable refresh interval
• Configuration via TOML file (~/.config/bottom/bottom.toml)
• Cross-platform: identical experience on Linux, macOS, and Windows
• Extremely low memory footprint (typically under 10MB RSS)
• Supports both light and dark terminal themes

Installation

Ubuntu/Debian (via apt on recent versions):

1

sudo apt install bottom

Arch Linux:

1

sudo pacman -S bottom

macOS (Homebrew):

1

brew install bottom

Cargo (Rust):

1

cargo install bottom

Binary download:

1
2

curl -LO https://github.com/ClementTsang/bottom/releases/download/0.10.2/bottom_0.10.2_amd64.deb
sudo dpkg -i bottom_0.10.2_amd64.deb

Docker Container

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# docker-compose.yml
version: "3.8"
services:
  bottom:
    image: alpine:latest
    container_name: bottom
    restart: unless-stopped
    volumes:
      - /proc:/proc:ro
      - /sys:/sys:ro
    command: >
      sh -c "
        apk add --no-cache bottom &&
        btm
      "
    environment:
      - TERM=xterm-256color
    tty: true
    stdin_open: true

Configuration Example

Bottom’s TOML configuration is clean and readable:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# ~/.config/bottom/bottom.toml
[flags]
default_widget_type = "proc"
process_default_tree = true
rate = "1000ms"

[colors]
table_header_color = "#f0f0f0"
all_cpu_color = "#50fa7b"
avg_cpu_color = "#ffb86c"

[processes]
default_search_case_insensitive = true

Feature Comparison

Performance Benchmarks

On a 4-core VPS with 2GB RAM running Ubuntu 24.04, here’s how each tool performs during normal operation:

btop’s C++ implementation gives it an excellent balance of features and performance. Glances’ Python overhead is noticeable on resource-constrained systems but is the trade-off for its extensive plugin ecosystem. Bottom’s Rust foundation makes it the lightest option — ideal for containers or low-power devices.

Choosing the Right Tool

Pick btop if:

• You want the most polished, feature-rich terminal monitor
• GPU monitoring matters (NVIDIA, AMD, Intel)
• You value mouse support and rich theming
• You primarily work on Linux or macOS
• You want the best-looking option for terminal screenshots and demos

Pick glances if:

• You need to export metrics to external systems (Prometheus, InfluxDB, etc.)
• You want to monitor Docker containers from the terminal
• You need client/server mode for multi-host monitoring
• You occasionally want a web UI without deploying a separate dashboard
• You’re willing to accept higher resource usage for broader functionality

Pick bottom if:

• You need the lightest possible memory and CPU footprint
• Cross-platform consistency (Linux/macOS/Windows) is important
• You prefer simple, TOML-based configuration
• You’re running on resource-constrained hardware (Raspberry Pi, small VPS)
• You want fast startup times for quick checks

Practical Deployment: Terminal Monitoring on a Self-Hosted Server

Here’s a practical setup for a homelab or small self-hosted environment using all three tools strategically:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#!/bin/bash
# monitor-setup.sh - Install all three tools for different use cases

# btop for interactive, detailed monitoring on primary servers
sudo apt install -y btop

# glances for Docker monitoring and metric export
pip install glances[docker,web,prometheus]

# bottom for lightweight checks on resource-constrained nodes
curl -LO https://github.com/ClementTsang/bottom/releases/download/0.10.2/bottom_0.10.2_amd64.deb
sudo dpkg -i bottom_0.10.2_amd64.deb

# Set up a systemd service for glances web + prometheus export
sudo tee /etc/systemd/system/glances-web.service << 'EOF'
[Unit]
Description=Glances System Monitor (Web + Prometheus)
After=network.target

[Service]
Type=simple
User=root
ExecStart=/usr/local/bin/glances -w --export prometheus
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable --now glances-web

With this setup:

• SSH into any server and run btop for detailed interactive monitoring
• Use btm (bottom) on lightweight nodes or containers for quick checks
• Access http://server:61208 from a browser for a quick web view
• Scrape Prometheus metrics from glances for long-term storage in your observability stack

Keyboard Shortcuts Reference

btop

glances

bottom

Conclusion

Terminal dashboards are not a replacement for full observability stacks — they’re a complement. Prometheus and Grafana tell you what happened over the last week. btop, glances, and bottom tell you what’s happening right now, with zero setup and zero dependencies.

For most self-hosted setups, btop is the best daily driver — it has the richest feature set, the best visuals, and excellent performance. Glances earns its place when you need Docker monitoring or metric export capabilities. Bottom is the go-to choice for minimal resource usage and cross-platform consistency.

Install all three, use each where it shines, and you’ll never need to guess what your servers are doing again.

Frequently Asked Questions (FAQ)

Which one should I choose in 2026?

The best choice depends on your specific requirements:

• For beginners: Start with the simplest option that covers your core use case
• For production: Choose the solution with the most active community and documentation
• For teams: Look for collaboration features and user management
• For privacy: Prefer fully open-source, self-hosted options with no telemetry

Refer to the comparison table above for detailed feature breakdowns.

Can I migrate between these tools?

Most tools support data import/export. Always:

1. Backup your current data
2. Test the migration on a staging environment
3. Check official migration guides in the documentation

Are there free versions available?

All tools in this guide offer free, open-source editions. Some also provide paid plans with additional features, priority support, or managed hosting.

How do I get started?

1. Review the comparison table to identify your requirements
2. Visit the official documentation (links provided above)
3. Start with a Docker Compose setup for easy testing
4. Join the community forums for troubleshooting