Glances

An Eye on your System

Important

The current stable release is Glances 4.5.8: see the v4.5.8 tag for its source code and documentation. pip install glances installs it.

This branch (develop) contains Glances 5.0.0, currently in beta. The rest of this page describes Glances 5.

Warning

Try Glances 5 (beta) — for testing only:

• it is a beta: expect bugs, and do not use it in production;
• the API is broken compared to Glances 4: the REST API moves from /api/4 to /api/5, the Python API is new, and a Glances 5 client only talks to a Glances 5 server (no XML-RPC anymore);
• configuration files from Glances 4 are read, but some options changed.

Install the beta from TestPyPI in a dedicated virtual environment (dependencies still come from PyPI):

python3 -m venv ~/.venv-glances5
source ~/.venv-glances5/bin/activate
pip install --pre --index-url https://test.pypi.org/simple/ \
    --extra-index-url https://pypi.org/simple/ 'glances[web]>=5.0.0b1'
glances --version

Or run the nicolargo/glances:dev Docker image (built from this branch). Please report what you find in the GitHub issues.

Summary 🌟

Glances is an open-source, cross-platform system monitoring tool. It shows in real time CPU, memory, load, disks, file systems, network, sensors (temperatures, voltages, fans, battery), GPUs, NPUs and processes. It also monitors containers (Docker, Podman, LXD) and virtual machines (Multipass, libvirt). Everything is presented in an easy-to-read dashboard, in the terminal or in a Web browser, and you choose what to display.

In client/server mode, remote monitoring could be done via terminal, Web interface or RESTful API. Stats can also be exported to files or external time/value databases, CSV or direct output to STDOUT.

AI assistants (Claude, Cursor, …) can query Glances directly through the built-in MCP server.

Glances is written in Python and uses libraries to grab information from your system. It is based on an open architecture where developers can add new plugins or exports modules. It can also be used as a Python library in your own scripts and notebooks.

Usage 👋

Glances can be used in the following modes.

1. TUI (standalone mode)

Monitor the local machine in your terminal:

$ glances

Press h in the interface to display the hotkeys.

2. WebUI (Web server mode)

Start the Web server (REST API and WebUI):

$ glances -s

(-w is an alias of -s) and enter the URL http://localhost:61208 in your favorite web browser.

The server listens on 127.0.0.1 by default. To reach it from another machine, listen on all interfaces with -B 0.0.0.0 (or bind_address in the [outputs] section of the configuration file) and enter the URL http://<ip>:61208.

The same server exposes a HTTP/RESTful API under /api/5, see the RestfulApi documentation. It is not protected by default, see Advanced usage 🔧 to set a password.

3. TUI client / server mode

Start a server on the machine to monitor:

server$ glances -s -B 0.0.0.0

and display it in the terminal of another machine:

client$ glances -c <server_ip>

The client reads the stats from the server REST API (use --password to be prompted for the server password). A Glances 5 client only talks to a Glances 5 server.

4. TUI browser

List all Glances servers available on your network (Zeroconf) or defined in the [serverlist] section of the configuration file, then open one of them:

$ glances --browser

5. WebUI browser

The same servers list, served in a Web page at http://<ip>:61208/browser:

$ glances -s --browser

6. MCP server

Start the Web server with the MCP (Model Context Protocol) server enabled:

$ glances -s --enable-mcp

The MCP endpoint is then available at http://<ip>:61208/mcp (Streamable HTTP) and http://<ip>:61208/mcp/sse (SSE, for older clients); the startup log gives both. Plug it into your AI assistant (here opencode) and ask it for the state of the machine:

$ opencode mcp add glances --url http://localhost:61208/mcp

See the McpApi documentation for client configuration and usage.

7. Fetch mode

Get (and share) a quick look of a machine, then exit:

$ glances --fetch

The output can be customized with a Jinja template (--fetch-template), see the Fetch documentation.

Advanced usage 🔧

Display raw stats on stdout:

$ glances --stdout cpu.user,mem.used,load
cpu.user: 30.7
mem.used: 3278204928
load: {'min1': 0.21, 'min5': 0.4, 'min15': 0.27, 'cpucore': 4}
cpu.user: 3.4
mem.used: 3275251712
load: {'min1': 0.19, 'min5': 0.39, 'min15': 0.27, 'cpucore': 4}
...

or in a CSV format thanks to the stdout-csv option:

$ glances --stdout-csv now,cpu.user,mem.used,load
now.iso,now.custom,cpu.user,mem.used,load.min1,load.min5,load.min15,load.cpucore
2026-10-11T15:12:54+00:00,2026-10-11 15:12:54 UTC,7.3,5948149760,1.04,0.99,1.04,4
2026-10-11T15:12:56+00:00,2026-10-11 15:12:56 UTC,5.4,5949136896,1.04,0.99,1.04,4
...

or in a JSON format thanks to the stdout-json option (one JSON object per refresh, attribute not supported in this mode):

$ glances --stdout-json cpu,mem
{"cpu": {"user": 24.7, "system": 3.8, "idle": 71.4, "nice": 0.0, "iowait": 0.0, "irq": 0.0, "steal": 0.0, "guest": 0.0, "total": 29.0, "ctx_switches": 0, "interrupts": 0, "soft_interrupts": 0, "syscalls": 0, "cpucore": 4}, "mem": {"total": 7837949952, "available": 2919079936, "percent": 62.8, "used": 4918870016, "free": 2919079936, "active": 2841214976, "inactive": 3340550144, "buffers": 546799616, "cached": 3068141568, "shared": 788156416, "slab": 158588928}}
...

Export stats without any interface, thanks to the quiet mode:

$ glances -q --export csv --export-csv-file /tmp/glances.csv

Protect the Web server with a password: generate a password hash

$ glances --set-password

and paste the printed value into the password key of the [outputs] section of your glances.conf file.

Serve the REST API without the WebUI, and browse its interactive documentation (Swagger at /docs, ReDoc at /redoc):

$ glances -s --disable-webui --api-doc

Choose what is collected and displayed:

$ glances --modules-list                     # list plugins and exporters
$ glances --disable-plugin sensors,wifi      # do not collect these plugins
$ glances -t 5                               # refresh every 5 seconds
$ glances -f 'python.*'                      # filter the process list

Use another configuration file with -C <path>, or override any key with an environment variable GLANCES_<SECTION>__<KEY>=<value> (handy in containers), see the Configuration documentation.

Report a bug: glances --issue tests every plugin and prints a Markdown report to paste into the GitHub issue.

If you do not want to remember all those options, @yottajunaid has created a simple launcher for Linux.

Use Glances as a Python library 📚

Every Glances plugin is available from Python, as a read-only mapping:

>>> from glances import api
>>> gl = api.GlancesAPI()
>>> gl.cpu["total"]
6.8
>>> gl.auto_unit(gl.mem["used"])
'9.45G'
>>> gl.network.keys()
['wlp0s20f3', 'mpqemubrzone1', 'tap-8d309783ee6']
>>> gl.network["wlp0s20f3"]["bytes_recv"]
101.7532271038767
>>> [p["name"] for p in gl.top_process(limit=3)]
['Isolated Web Co', 'terminator', 'claude']
>>> gl.plugins()
['amps', 'containers', 'core', 'cpu', 'diskio', 'folders', 'fs', 'gpu', 'ip', ...]

By default the stats are collected on demand, when they are read. In a notebook or a long-running tool, let Glances collect them in the background, so the history and the alerts fill up between two reads:

>>> import time
>>> with api.GlancesAPI(background=True, plugins=["cpu", "mem"]) as gl:
...     time.sleep(60)
...     gl.cpu.history(nb=30)
...     gl.alerts()

Each plugin view also gives its fields description (.fields), its thresholds (.limits) and its alert levels (.levels). The API reads glances.conf as Glances does, but never runs the configured actions nor the exporters.

The Glances 5 Python API replaces the Glances 4 one. See the PythonApi documentation for the complete reference.

Documentation 📜

The complete documentation is on readthedocs:

Topic	Content
🚀 Quickstart	First steps, modes and hotkeys
⌨️ Command reference	All the command line options
⚙️ Configuration	The glances.conf file
📊 Plugins	What every plugin shows, and how to tune it
🌐 Exports	Gateways to other services
🔌 RestfulApi / PythonApi / McpApi	The APIs
🐳 Docker	Run Glances in a container
❓ FAQ	Frequently asked questions

If you have any question (after RTFM! and the FAQ), please post it on the official Reddit forum or in GitHub Discussions.

Gateway to other services 🌐

Glances can export its stats to:

📁 Files
📈 Time series
🗄️ Databases
📨 Message brokers
🔗 HTTP

Installation 🚀

The methods below install the latest stable release (Glances 4.5.8 today). To test Glances 5, see the beta box at the top of this page.

PyPI: pip, pipx or uv

Glances is on PyPI. Install it in a virtual environment with pip:

python3 -m venv ~/.venv
source ~/.venv/bin/activate
pip install 'glances[all]'

or, as an isolated application, with pipx or Uv:

pipx install 'glances[all]'    # installed in ~/.local/bin
uvx glances                     # install and run in one line

To upgrade: pip install --upgrade glances (or pipx upgrade glances).

pip install glances (without extra) installs a minimal Glances, without the Web interface. Pick only the features you need between the brackets, for example pip install 'glances[web,containers]':

Extra	Feature
all	All the features below
web	Web server mode (WebUI and REST API)
mcp	MCP server (AI assistant integration)
browser	Servers autodiscovery for the browser modes
containers	Docker, Podman and LXD containers
gpu	NVIDIA GPU
sensors	Battery (Linux)
raid / smart / wifi	RAID, S.M.A.R.T. and Wifi plugins (Linux)
cloud	Cloud instance metadata
action	Mustache templating in the alert actions
export / graph	Export modules / SVG graph export

Note: psutil, the main Glances dependency, is built from source when no wheel is available for your platform. Python headers and a C compiler are then required (python3-dev and gcc on Debian/Ubuntu, python3-devel on Fedora/RHEL).

Docker: the cloudy way

Glances Docker images are available. You can use it to monitor your server and all your containers !

The following tags are available:

• latest-full for a full Alpine Glances image (latest release) with all dependencies
• latest for a basic Alpine Glances (latest release) version with minimal dependencies (FastAPI and Docker)
• dev for a basic Alpine Glances image (based on development branch) with all dependencies (Warning: may be instable)
• ubuntu-latest-full for a full Ubuntu Glances image (latest release) with all dependencies
• ubuntu-latest for a basic Ubuntu Glances (latest release) version with minimal dependencies (FastAPI and Docker)
• ubuntu-dev for a basic Ubuntu Glances image (based on development branch) with all dependencies (Warning: may be instable)
• <version> and <version>-full (for example 5.0.0b1-full), and their ubuntu- variants, for a given release

A pre-release (beta or release candidate) is only published under its version tags: it never moves the latest tags.

Run last version of Glances container in console mode:

docker run --rm -e TZ="${TZ}" -v /var/run/docker.sock:/var/run/docker.sock:ro -v /run/user/1000/podman/podman.sock:/run/user/1000/podman/podman.sock:ro --pid host --network host -it nicolargo/glances:latest-full

By default, the /etc/glances/glances.conf file is used (based on docker-compose/glances.conf). This file sets bind_address=0.0.0.0 in the [outputs] section, so that the Web server mode is reachable from outside the container. On a shared network, also set [outputs] password and webui_allowed_hosts (see the configuration documentation). Mounting the Docker socket :ro protects the file, not the Docker API: the container can still drive the daemon.

Additionally, if you want to use your own glances.conf file, you can create your own Dockerfile:

FROM nicolargo/glances:latest
COPY glances.conf /root/.config/glances/glances.conf
CMD python -m glances -C /root/.config/glances/glances.conf $GLANCES_OPT

Alternatively, you can specify something along the same lines with docker run options (notice the GLANCES_OPT environment variable setting parameters for the glances startup command):

docker run -e TZ="${TZ}" -v $HOME/.config/glances/glances.conf:/glances.conf:ro -v /var/run/docker.sock:/var/run/docker.sock:ro -v /run/user/1000/podman/podman.sock:/run/user/1000/podman/podman.sock:ro --pid host -e GLANCES_OPT="-C /glances.conf" -it nicolargo/glances:latest-full

Where $HOME/.config/glances/glances.conf is a local directory containing your glances.conf file.

With -C, only the given file is read: set bind_address=0.0.0.0 in its [outputs] section (or add -B 0.0.0.0 to GLANCES_OPT) to use the Web server mode.

Run the container in Web server mode (and MCP server):

docker run -d --restart="always" -p 61208:61208 -e TZ="${TZ}" -e GLANCES_OPT="-w --enable-mcp" -v /var/run/docker.sock:/var/run/docker.sock:ro -v /run/user/1000/podman/podman.sock:/run/user/1000/podman/podman.sock:ro --pid host nicolargo/glances:latest-full

For a full list of options, see the Glances Docker documentation page.

Docker compose: Yet Another Cloudy Way

It is also possible to use a simple Docker compose file to:

• run the Web (Rest API and WebUI) and the MCP server (see in ./docker-compose/docker-compose.yml):

mkdir -p ~/glances-compose
cd ~/glances-compose
wget https://raw.githubusercontent.com/nicolargo/glances/refs/heads/develop/docker-compose/docker-compose.yml
wget https://raw.githubusercontent.com/nicolargo/glances/refs/heads/develop/docker-compose/glances.conf
docker compose up

• or run the terminal client (TUI):

mkdir -p ~/glances-compose
cd ~/glances-compose
wget https://raw.githubusercontent.com/nicolargo/glances/refs/heads/develop/docker-compose/docker-compose-tui.yml
wget https://raw.githubusercontent.com/nicolargo/glances/refs/heads/develop/docker-compose/glances.conf
docker compose -f ./docker-compose-tui.yml run glances

Shell tab completion 🔍

Glances includes shell tab autocompletion thanks to the --print-completion option.

For example, on a Linux operating system with bash shell:

$ mkdir -p ${XDG_DATA_HOME:="$HOME/.local/share"}/bash-completion
$ glances --print-completion bash > ${XDG_DATA_HOME:="$HOME/.local/share"}/bash-completion/glances
$ source ${XDG_DATA_HOME:="$HOME/.local/share"}/bash-completion/glances

Following shells are supported: bash, zsh, tcsh, fish and powershell.

Requirements 🧩

Glances 5 requires Python 3.10 or higher (tested up to Python 3.14) and runs on Linux, macOS, FreeBSD and Windows.

Core dependencies (always installed):

• psutil (system stats, better with the latest version)
• requests (client mode, Ports and Cloud plugins, RESTful export module)
• jinja2 (fetch mode and templating)
• shtab (shell autocompletion) [All but Windows]
• windows-curses (curses implementation) [Windows only]

Optional dependencies, by extra (see the [project.optional-dependencies] section of pyproject.toml for the exact versions):

Extra	Dependencies
web	fastapi, uvicorn, starlette, python-jose, msgpack
mcp	mcp
browser	zeroconf
containers	docker, podman, pylxd (and packaging, python-dateutil, six)
gpu	nvidia-ml-py
sensors	batinfo [Linux only]
raid	pymdstat [Linux only]
smart	pySMART [Linux only]
wifi	wifi [Linux only]
cloud	requests
action	chevron
graph	pygal
export	bernhard, clickhouse-connect, elasticsearch, graphitesender, ibmcloudant, influxdb, influxdb-client, influxdb3-python, kafka-python, nats-py, paho-mqtt, pika, potsdb, prometheus_client, psycopg[binary], pymongo, pyzmq, statsd, pycouchdb

Note: the export extra installs the libraries of all the export modules. If you only use one or a few exports, prefer to install only the library of the wanted export (for example pip install glances influxdb-client for InfluxDB 2).

duckdb (DuckDB export module) is not included in any extra, install it manually if needed.

How to contribute ? 🤝

If you want to contribute to the Glances project, read this wiki page.

There is also a chat dedicated to the Glances developers:

Project sponsorship 🙌

You can help me to achieve my goals of improving this open-source project or just say "thank you" by:

• sponsor me using one-time or monthly tier Github sponsors page
• send me some pieces of bitcoin: 185KN9FCix3svJYp7JQM7hRMfSKyeaJR4X

Any and all contributions are greatly appreciated.

Authors and Contributors 🔥

Glances has been created by Nicolas Hennion (@nicolargo) <nicolas@nicolargo.com>

and developed by a wonderfull contributors community.

License 📜

Glances is distributed under the LGPL version 3 license. See COPYING for more details.