bottom is a free, open source monitoring & observability project written in Rust and released under MIT. It has 14,147 GitHub stars, 402 forks and 103 open issues, and was last pushed 14 hours ago. On this registry it ranks #28 of 270 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available. It gained 72 stars over the last 30 tracked days.

What is bottom?

bottom is a customizable cross-platform graphical process and system monitor that runs inside the terminal, written in Rust and aimed at developers, system administrators, and anyone who wants an interactive view of CPU, memory, network, disk, and process activity without leaving the shell.

What it is

bottom (invoked as btm) is a terminal user interface application that renders live system and process information as graphical widgets. It officially supports Linux, macOS, and Windows across the architectures the README lists, and it is distributed both as a crate on crates.io and through a long list of package managers and prebuilt binaries. The project is MIT licensed, developed by ClementTsang, and documents its behaviour at https://bottom.pages.dev.

It lives in the terminal monitoring ecosystem alongside top and the tools the README names as its inspirations, htop, gtop, and gotop. What it offers in place of a plain-text top session is a set of time-series widgets: CPU usage shown at both an average and a per-core level, RAM and swap usage, network I/O, temperature, and disk I/O, all plotted over time with support for zooming in and out of the displayed interval. The configuration story is likewise broader than a fixed column layout, since widget behaviour, layout, colour themes, and per-widget entry filtering can all be controlled either with command-line options or with a config file.

Key capabilities

  • Graphical widgets for CPU usage over time at an average and per-core level, RAM and swap usage over time, network I/O, temperature, and disk I/O, with zooming in and out of the current time interval.
  • Info widgets covering disk capacity and usage, temperature sensors, and battery usage.
  • A process widget that displays, sorts, and searches process information, with kill signal support and a tree mode.
  • Customizable behaviour through command-line options or a config file, including custom and built-in colour themes such as --theme gruvbox, widget behaviour changes, layout changes, and filtering entries out of widgets.
  • An htop-inspired basic mode for users who want the familiar single-view layout.
  • Expansion of a single widget to fill the screen when one metric needs undivided attention.
  • Shell auto-completion, with binaries available from Cargo, distro repositories, Homebrew, Chocolatey, Scoop, winget, an MSI installer, Snap, Nix, Conda, mise, and prebuilt downloads.

Who uses it and how

  • Developers and operators who work primarily in a terminal and want monitoring that costs no browser tab, no agent, and no separate daemon.
  • Administrators running it on Linux hosts, including headless or remote machines where the terminal is the interface they already have.
  • macOS users on x86_64 and aarch64, and Windows users on x86_64 and i686, using the Homebrew, MacPorts, Chocolatey, Scoop, winget, or MSI routes the README documents.
  • Teams standardized on a single monitoring layout, since a config file can carry themes, widget arrangement, and filters to every machine instead of relying on per-session flags.
  • Users who want a middle ground between a raw top output and a full graphical desktop monitor.

Getting started

Install with cargo install bottom, or use whichever package manager matches the platform, since the README documents Cargo, Alpine, Arch, Debian/Ubuntu, Fedora/CentOS/AlmaLinux/Rocky, COPR, Gentoo, Nix, openSUSE, Snap, Solus, Void, Homebrew, MacPorts, Chocolatey, Scoop, winget, Conda, mise, gah, ghr, and prebuilt binaries. Documentation for both the stable and nightly builds is published at https://bottom.pages.dev.

How it compares

The README names three similar tools directly, htop, gtop, and gotop, and places bottom in the same lineage as a cross-platform terminal monitor built with the newer graphical widget set. It differs from the older htop in being written in Rust and in offering time-series graphs, battery and disk widgets, tree mode, and a config file alongside the htop-inspired basic mode. No paid products are listed anywhere in the provided facts, so no licence, hosting, or cost comparison against commercial monitoring services can honestly be drawn here.

When to use it — and when not to

bottom targets one machine at a time: it is an interactive terminal view, and the documented feature set contains no agent, no server component, no remote aggregation, and no persistent metrics store, so it is not a substitute for a fleet-wide observability platform or for retaining history after the session closes. Because everything is local and configuration lives in a file the user supplies, there is nothing extra to operate, no database, no SMTP, and no storage to provision. Anyone who needs alerting, long-term retention, or multi-host dashboards should look elsewhere, and anyone who wants a stable, unchanging interface should note that the project publishes both stable and nightly documentation branches, which reflects ongoing widget and configuration churn.

project readme (upstream, from github) — read inline

bottom (btm)

A customizable cross-platform graphical process/system monitor for the terminal.
Supports Linux, macOS, and Windows. Inspired by gtop, gotop, and htop.

crates.io link Stable documentation Nightly documentation Doc mirror on GitHub Pages Ko-fi link

Demo using the Gruvbox theme (--theme gruvbox), along with IBM Plex Mono and Kitty

Table of contents

Features

As (yet another) process/system visualization and management application, bottom supports the typical features:

You can find more details in the documentation.

Support

Official

bottom officially supports the following operating systems and corresponding architectures:

  • macOS (x86_64, aarch64)
  • Linux (x86_64, i686, aarch64)
  • Windows (x86_64, i686)

These platforms are tested to work for the most part and issues on these platforms will be fixed if possible. Furthermore, binaries are built and tested using the most recent version of stable Rust at the time.

For more details on supported platforms and known problems, check out the documentation.

Unofficial

bottom may work on a number of platforms that aren't officially supported. Note that unsupported platforms:

  • Might not be tested in CI to build or pass tests (see here for checked platforms).
  • Might not be properly tested by maintainers prior to a stable release.
  • May only receive limited support, such as missing features or bugs that may not be fixed.

Note that some unsupported platforms may eventually be officially supported (e.g., FreeBSD).

A non-comprehensive list of some currently unofficially-supported platforms that may compile/work include:

  • FreeBSD (x86_64)
  • Linux (armv6, armv7, powerpc64le, riscv64gc, loongarch64)
  • Android (arm64)
  • Windows (arm64)
  • NetBSD (x86_64)

For more details on unsupported platforms and known problems, check out the documentation.

Installation

Cargo

Installation via cargo can be done by installing the bottom crate:

# You might need to update the stable version of Rust first.
# Other versions might work, but this is not guaranteed.
rustup update stable

# Install the binary from crates.io.
cargo install bottom --locked

# If you use another channel by default, you can specify
# the what channel to use like so:
cargo +stable install bottom --locked

# --locked may be omitted if you wish to not use the
# locked crate versions in Cargo.lock. However, be
# aware that this may cause problems with dependencies.
cargo install bottom

Alternatively, you can use cargo install using the repo as the source.

# You might need to update the stable version of Rust first.
# Other versions might work, but this is not guaranteed.
rustup update stable

# Option 1 - Download an archive from releases and install
curl -LO https://github.com/ClementTsang/bottom/archive/0.14.9.tar.gz
tar -xzvf 0.14.9.tar.gz
cargo install --path . --locked

# Option 2 - Manually clone the repo and install
git clone https://github.com/ClementTsang/bottom
cd bottom
cargo install --path . --locked

# Option 3 - Install using cargo with the repo as the source
cargo install --git https://github.com/ClementTsang/bottom --locked

# You can also pass in the target-cpu=native flag to try to
# use better CPU-specific optimizations. For example:
RUSTFLAGS="-C target-cpu=native" cargo install --path . --locked

Alpine

bottom is available as a package for Alpine Linux via apk:

apk add bottom

Packages for documentation (bottom-doc) and completions for Bash (bottom-bash-completion), Fish (bottom-fish-completion), and Zsh (bottom-zsh-completion) are also available.

Arch Linux

bottom is available as an official package that can be installed with pacman:

sudo pacman -S bottom

If you want the latest changes that are not yet stable, you can also install bottom-git from the AUR:

# Using paru
paru -S bottom-git

# Using yay
yay -S bottom-git

Debian / Ubuntu

A .deb file is provided on each stable release and nightly builds for x86, aarch64, and armv7. Some examples of installing it this way:

# x86-64
curl -LO https://github.com/ClementTsang/bottom/releases/download/0.14.9/bottom_0.14.9-1_amd64.deb
sudo dpkg -i bottom_0.14.9-1_amd64.deb

# ARM64
curl -LO https://github.com/ClementTsang/bottom/releases/download/0.14.9/bottom_0.14.9-1_arm64.deb
sudo dpkg -i bottom_0.14.9-1_arm64.deb

# ARM
curl -LO https://github.com/ClementTsang/bottom/releases/download/0.14.9/bottom_0.14.9-1_armhf.deb
sudo dpkg -i bottom_0.14.9-1_armhf.deb

# musl-based
curl -LO https://github.com/ClementTsang/bottom/releases/download/0.14.9/bottom-musl_0.14.9-1_amd64.deb
sudo dpkg -i bottom-musl_0.14.9-1_amd64.deb

Exherbo Linux

bottom is available as a rust package that can be installed with cave:

cave resolve -x repository/rust
cave resolve -x bottom

Fedora / CentOS / AlmaLinux / Rocky Linux

COPR

[!WARNING]

atim/bottom seems to be unmaintained and may be outdated (relevant issue)

bottom is available on COPR:

sudo dnf copr enable atim/bottom -y
sudo dnf install bottom
Terra

bottom is also available via Terra:

sudo dnf install --repofrompath 'terra,https://repos.fyralabs.com/terra$releasever' --setopt='terra.gpgkey=https://repos.fyralabs.com/terra$releasever/key.asc' terra-release
sudo dnf install bottom
RPM

.rpm files are also generated for x86 in the releases page. For example:

curl -LO https://github.com/ClementTsang/bottom/releases/download/0.14.9/bottom-0.14.9-1.x86_64.rpm
sudo dnf install ./bottom-0.14.9-1.x86_64.rpm

Gentoo

Available in the official Gentoo repo:

sudo emerge --ask sys-process/bottom

Nix

Available in Nixpkgs as bottom:

nix profile install nixpkgs#bottom

bottom can also be installed and configured through the home-manager module:

{
  programs.bottom.enable = true;
}

openSUSE

Available in openSUSE Tumbleweed:

zypper in bottom

Snap

bottom is available as a snap:

sudo snap install bottom

# To allow the program to run as intended
sudo snap connect bottom:mount-observe
sudo snap connect bottom:hardware-observe
sudo snap connect bottom:system-observe
sudo snap connect bottom:process-control

Solus

Available in the Solus repos:

sudo eopkg it bottom

Void

Available in the void-packages repo:

sudo xbps-install bottom

Homebrew

The formula is available here:

brew install bottom

MacPorts

Available here:

sudo port selfupdate
sudo port install bottom

Chocolatey

Chocolatey packages are located here:

choco install bottom

Scoop

Available in the Main bucket:

scoop install bottom

winget

The winget package can be found here:

winget install bottom

# If you need a more specific app id:
winget install Clement.bottom

You can uninstall via Control Panel, Options, or winget --uninstall bottom.

Windows installer (MSI)

You can manually install bottom as a Windows program by downloading and using the .msi file from the latest release.

Conda

You can install bottom using conda with this conda-smithy repository:

# Add the channel
conda config --add channels conda-forge
conda config --set channel_priority strict

# Install
conda install bottom

gah

bottom can also be installed on Linux or macOS using gah:

gah install bottom

ghr

bottom can be installed using ghr like so:

ghr install clementtsang/bottom

mise

bottom is available via mise:

mise use -g bottom@latest

Pre-built binaries

You can also use the pre-built release binaries:

To use, download and extract the binary that matches your system. You can then run by doing:

./btm

or by installing to your system following the procedures for installing binaries to your system.

Auto-completion

The release binaries in the releases page are packaged with shell auto-completion files for Bash, Zsh, fish, Powershell, Elvish, Fig, and Nushell. To install them:

  • For Bash, move btm.bash to $XDG_CONFIG_HOME/bash_completion or /etc/bash_completion.d/.
  • For Zsh, move _btm to one of your $fpath directories.
  • For fish, move btm.fish to $HOME/.config/fish/completions/.
  • For PowerShell, add _btm.ps1 to your PowerShell profile.
  • For Elvish, the completion file is btm.elv.
  • For Fig, the completion file is btm.ts.
  • For Nushell, use btm.nu.

The individual auto-completion files are also included in the stable/nightly releases as completion.tar.gz if needed.

Usage

You can run bottom using btm.

  • For help on flags, use btm -h for a quick overview or btm --help for more details.
  • For info on key and mouse bindings, press ? inside bottom or refer to the documentation page.

You can find more information on usage in the documentation.

Configuration

bottom accepts a number of command-line arguments to change the behaviour of the application as desired. Additionally, bottom will automatically generate a configuration file on the first launch, which can be changed.

More details on configuration can be found in the documentation.

Troubleshooting

If some things aren't working, give the troubleshooting page a look. If things still aren't working, then consider asking a question or filing a bug report if you think it's a bug.

Documentation

The main documentation page can be found at , using Cloudflare Pages. If needed, a mirror hosted using Github Pages is also available at .

Contribution

Whether it's reporting bugs, suggesting features, maintaining packages, or submitting a PR, contribution is always welcome! Please read CONTRIBUTING.md for details on how to contribute to bottom.

Contributors

Thanks to all contributors:

Marcin Wojnarowski
Marcin Wojnarowski

💻 📦
Mahmoud Al-Qudsi
Mahmoud Al-Qudsi

💻
Andy
Andy

💻
Kim Brose
Kim Brose

💻
Sven-Hendrik Haase
Sven-Hendrik Haase

📖
Artem Polishchuk
Artem Polishchuk

📦 📖
Trung Lê
Trung Lê

📦 🚇
dm9pZCAq
dm9pZCAq

📦 📖
Lukas Rysavy
Lukas Rysavy

💻
Erlend Hamberg
Erlend Hamberg

💻
Frederick Zhang
Frederick Zhang

💻
pvanheus
pvanheus

💻
Brian Di Palma
Brian Di Palma

📖
Lasha Kanteladze
Lasha Kanteladze

📖
Herby Gillot
Herby Gillot

📖
Greg Brown
Greg Brown

💻
TotalCaesar659
TotalCaesar659

📖
George Rawlinson
George Rawlinson

📖 📦
adiabatic
adiabatic

📖
Randy Barlow
Randy Barlow

💻
Patrick Jackson
Patrick Jackson

🤔 📖
Mateusz Mikuła
Mateusz Mikuła

💻
Guillaume Gomez
Guillaume Gomez

💻
shura
shura

💻
Wesley Moore
Wesley Moore

💻
xgdgsc
xgdgsc

📖
ViridiCanis
ViridiCanis

💻
Justin Martin
Justin Martin

💻 📖
Diana
Diana

💻
Hervy Qurrotul Ainur Rozi
Hervy Qurrotul Ainur Rozi

📖
Mike Rivnak
Mike Rivnak

📖
lroobrou
lroobrou

💻
database64128
database64128

💻
Chon Sou
Chon Sou

💻
DrSheppard
DrSheppard

📖
Rareș Constantin
Rareș Constantin

💻
felipesuri
felipesuri

📖
spital
spital

💻
Michael Bikovitsky
Michael Bikovitsky

💻
Dmitry Valter
Dmitry Valter

💻
Grace Stok
Grace Stok

💻
Yuxuan Shui
Yuxuan Shui

💻
Wenqing Zong
Wenqing Zong

💻
Gabriele Belluardo
Gabriele Belluardo

💻
Zeb Piasecki
Zeb Piasecki

💻
wzy
wzy

💻 📖
john-s-lin
john-s-lin

📖
Lee Wonjoon
Lee Wonjoon

💻 📖
David Legrand
David Legrand

📖
Michal Bryxí
Michal Bryxí

📖
Raphael Erik Hviding
Raphael Erik Hviding

💻
CosmicHorror
CosmicHorror

💻
Ben Woods
Ben Woods

📖
Stephen Huan
Stephen Huan

💻
Jason Gwartz
Jason Gwartz

📖
llc0930
llc0930

💻
Ada Ahmed
Ada Ahmed

💻
Wateir
Wateir

📖
Andrey Alekseenko
Andrey Alekseenko

💻
Fotis Gimian
Fotis Gimian

💻 📖
Fernando Rodrigues
Fernando Rodrigues

📖
Matthew Toohey
Matthew Toohey

💻
Julius Enriquez
Julius Enriquez

📖
Ben Brown
Ben Brown

💻
Yuri Astrakhan
Yuri Astrakhan

💻 📖
Kenichi Kamiya
Kenichi Kamiya

💻
yahlia
yahlia

💻
Bucket-Bucket-Bucket
Bucket-Bucket-Bucket

💻
Marek Sierociński
Marek Sierociński

📖
Tommaso Montanari
Tommaso Montanari

🎨 🤔
Jean-Yves LENHOF
Jean-Yves LENHOF

📖
Adarsh Das
Adarsh Das

💻 📖
rezky_nightky
rezky_nightky

📖
gitgoggles
gitgoggles

💻
Tom
Tom

🚧
G
G

📖
Filipe Paniguel
Filipe Paniguel

📖
Qiying Wang
Qiying Wang

💻
dastarruer
dastarruer

💻
ChrisJr404
ChrisJr404

💻
Gergő Gutyina
Gergő Gutyina

💻
Puneet Dixit
Puneet Dixit

💻
Umberto Puddu
Umberto Puddu

💻
Anis
Anis

💻
fazzi
fazzi

💻
Peder Bergan
Peder Bergan

💻

Thanks

  • This project is very much inspired by gotop, gtop, and htop.

  • This application was written with many, many libraries, as well as many services and programs, all built on top of the work of many talented people. bottom would not exist without all of this.

  • And of course, thank you again to all contributors and package maintainers!

  • I also really appreciate anyone who has used bottom, and those who go out of their way to report bugs or suggest ways to improve things. I hope it's been a useful tool for others.

  • To those who support my work financially via donations, thank you so much.

  • Thanks to JetBrains for providing access to tools that I use to develop bottom as part of their open source support program.

JetBrains logo

Frequently asked questions

Is bottom free to use?

bottom is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does bottom do?

Yet another cross-platform graphical process/system monitor.

What is bottom written in?

bottom is primarily written in Rust. Its source is publicly available at https://github.com/ClementTsang/bottom, and it has 14,147 GitHub stars.