bottom

Yet another cross-platform graphical process/system monitor.

9,759

231

9,759

100

View on GitHub

Top Related Projects

glances

26,263

Glances an Eye on your system. A top/htop alternative for GNU/Linux, BSD, Mac OS and Windows operating systems.

htop

6,293

htop - an interactive process viewer

gtop

9,693

System monitoring dashboard for terminal

ytop

2,155

A TUI system monitor written in Rust

s-tui

4,055

Terminal-based CPU stress and monitoring utility

Quick Overview

Bottom is a customizable cross-platform graphical process/system monitor for the terminal, similar to htop. It provides real-time information about CPU, memory, disk, network, and processes, with a clean and intuitive interface. Bottom is written in Rust and aims to be both performant and feature-rich.

Pros

Cross-platform support (Linux, macOS, Windows)
Highly customizable with themes and layout options
Lightweight and efficient, with low resource usage
Actively maintained and regularly updated

Cons

Steeper learning curve compared to simpler alternatives like htop
May require additional configuration for optimal use
Limited support for some advanced features on certain platforms
Relatively new project, so it may have fewer community resources compared to more established tools

Getting Started

To install Bottom, you can use one of the following methods:

Using Cargo (Rust's package manager):
```
cargo install bottom
```
On macOS using Homebrew:
```
brew install bottom
```
On Windows using Scoop:
```
scoop install bottom
```

After installation, simply run btm in your terminal to launch Bottom. You can customize the layout and appearance by creating a configuration file at ~/.config/bottom/bottom.toml (Unix-like systems) or %AppData%\bottom\bottom.toml (Windows).

For more detailed information on usage and configuration, refer to the project's documentation on GitHub.

Competitor Comparisons

btop

19,111

A monitor of resources

Pros of btop

Written in C++, potentially offering better performance
More customizable interface with themes and layout options
Supports a wider range of system information displays (e.g., detailed network stats)

Cons of btop

Less cross-platform compatibility (primarily Linux-focused)
Steeper learning curve due to more complex configuration options
Larger binary size and potentially higher resource usage

Code Comparison

btop (C++):

void Cpu::draw(const bool force) {
    if (force or should_draw) {
        auto& cpu_box = boxes.at("cpu");
        if (cpu_box.getHeight() < 1) return;
        cpu_box.clear();
        // ... (drawing logic)
    }
}

bottom (Rust):

pub fn draw_cpu(&mut self, f: &mut Frame<B>, area: Rect, force_redraw: bool) -> Result<()> {
    if !self.should_draw && !force_redraw {
        return Ok(());
    }
    // ... (drawing logic)
}

Both projects implement similar functionality for drawing CPU information, but btop uses C++ while bottom uses Rust. The btop implementation appears to have more direct control over the drawing process, while bottom's approach seems more abstracted and potentially safer due to Rust's memory safety features.

glances

26,263

Glances an Eye on your system. A top/htop alternative for GNU/Linux, BSD, Mac OS and Windows operating systems.

Pros of Glances

More comprehensive system monitoring, including network, disk I/O, and processes
Cross-platform support (Linux, macOS, Windows)
Web-based interface option for remote monitoring

Cons of Glances

Higher resource usage due to more extensive monitoring features
Less customizable interface compared to Bottom's widget-based approach

Code Comparison

Glances (Python):

from glances_api import GlancesApi

glances = GlancesApi(host='localhost', port=61208)
cpu_percent = glances.getCpu()['total']
print(f"CPU usage: {cpu_percent}%")

Bottom (Rust):

use bottom::data::CpuData;

let cpu_data = CpuData::new();
let cpu_percent = cpu_data.get_cpu_usage_percent();
println!("CPU usage: {}%", cpu_percent);

Summary

Glances offers a more comprehensive monitoring solution with cross-platform support and a web interface, making it suitable for remote monitoring and users who need detailed system information. However, it may consume more resources and has a less customizable interface.

Bottom, on the other hand, provides a lightweight and customizable terminal-based interface with a focus on performance. It's ideal for users who prefer a minimalist approach and want to tailor their monitoring experience.

The choice between the two depends on the specific monitoring needs, desired features, and performance considerations of the user.

htop

6,293

htop - an interactive process viewer

Pros of htop

More mature and widely adopted project with a longer history
Supports a broader range of Unix-like systems, including Linux, FreeBSD, and macOS
Offers more detailed process information and advanced sorting options

Cons of htop

Less visually appealing interface compared to bottom's modern design
Limited customization options for the UI layout and colors
Slower development cycle and less frequent updates

Code Comparison

htop (C):

void Process_writeCommand(Process* this, int writeComm) {
   if (this->comm && (Process_isThread(this) || writeComm)) {
      char* comm = this->comm;
      if (Process_isKernelThread(this)) {
         comm++;
      }
      xSnprintf(buffer, n, "%s", comm);
   } else {
      xSnprintf(buffer, n, "%s", this->cmdline[0]);
   }
}

bottom (Rust):

pub fn get_command(&self) -> String {
    if let Some(cmd) = &self.command {
        cmd.to_string()
    } else {
        self.name.clone()
    }
}

The code snippets show different approaches to retrieving process command information. htop uses C and handles various conditions, while bottom uses Rust with a more concise implementation.

gtop

9,693

System monitoring dashboard for terminal

Pros of gtop

Lightweight and simple to use
Written in JavaScript, making it accessible for web developers
Provides a clean, minimalist interface

Cons of gtop

Less feature-rich compared to bottom
Limited customization options
May not be as performant for monitoring large systems

Code Comparison

gtop:

const si = require('systeminformation');
const blessed = require('blessed');
const contrib = require('blessed-contrib');

// Main application logic

bottom:

use crossterm::event::{self, Event, KeyCode};
use std::io;
use std::time::Duration;

// Main application logic

Key Differences

bottom is written in Rust, which may offer better performance
bottom provides more detailed system information and customization options
gtop focuses on simplicity and ease of use
bottom offers a more comprehensive set of features for power users
gtop may be easier to extend or modify for JavaScript developers

Use Cases

Choose gtop for quick, simple system monitoring on smaller systems
Opt for bottom when detailed system analysis and customization are required
gtop is ideal for web developers who prefer working with JavaScript
bottom is better suited for systems administrators and power users who need in-depth information

ytop

2,155

A TUI system monitor written in Rust

Pros of ytop

Simpler and more lightweight interface
Faster startup time
Easier to use for basic system monitoring tasks

Cons of ytop

Less customizable and feature-rich
Limited to CPU, memory, and disk usage monitoring
No longer actively maintained (last commit in 2020)

Code Comparison

ytop (Rust):

pub fn get_cpu_usage() -> f64 {
    let cpu = sys_info::cpu_num().unwrap();
    let load = sys_info::loadavg().unwrap();
    load.one / cpu as f64 * 100.0
}

bottom (Rust):

pub fn get_cpu_usage_percent(
    cpu: &Cpu,
    prev_idle: &mut u64,
    prev_non_idle: &mut u64,
) -> f64 {
    let (idle, non_idle) = cpu.get_cpu_times();
    let delta_idle = idle - *prev_idle;
    let delta_non_idle = non_idle - *prev_non_idle;
    let delta_total = delta_idle + delta_non_idle;

    *prev_idle = idle;
    *prev_non_idle = non_idle;

    if delta_total == 0 {
        0.0
    } else {
        (delta_non_idle as f64 / delta_total as f64) * 100.0
    }
}

bottom offers a more detailed and accurate CPU usage calculation, while ytop provides a simpler implementation. This reflects the overall difference between the two projects, with bottom offering more advanced features and customization options, while ytop focuses on simplicity and ease of use.

s-tui

4,055

Terminal-based CPU stress and monitoring utility

Pros of s-tui

Written in Python, making it more accessible for contributions and modifications
Includes stress testing capabilities for CPU and memory
Offers a more detailed view of CPU frequencies and temperatures

Cons of s-tui

Less visually appealing interface compared to bottom's polished look
Limited to terminal-based usage, while bottom offers both CLI and TUI modes
Fewer customization options for the interface layout

Code Comparison

s-tui (Python):

def get_cpu_freq():
    cpu_freq = psutil.cpu_freq(percpu=True)
    return [float(x.current) for x in cpu_freq]

bottom (Rust):

pub fn get_cpu_data_list() -> Vec<CpuData> {
    sys.refresh_cpu();
    sys.cpus().iter().map(|cpu| CpuData::from(cpu)).collect()
}

Both projects aim to provide system monitoring capabilities, but they differ in their implementation and feature sets. s-tui focuses on CPU and memory monitoring with stress testing capabilities, while bottom offers a more comprehensive system overview with a polished interface. The choice between the two depends on specific monitoring needs and preferred programming language for potential modifications.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

bottom (btm)

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

Quick demo recording showing off bottom's searching, expanding, and process killing.

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

Features
Support
- Official
- Unofficial
Installation
Usage
Configuration
Troubleshooting
Contribution
- Contributors
Thanks

Features

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

Graphical visualization widgets for:
- CPU usage over time, at an average and per-core level
- RAM and swap usage over time
- Network I/O usage over time
with support for zooming in/out the current time interval displayed.
Widgets for displaying info about:
A process widget for displaying, sorting, and searching info about processes, as well as support for:
- Kill signals
- Tree mode
Cross-platform support for Linux, macOS, and Windows, with more planned in the future.
Customizable behaviour that can be controlled with command-line options or a config file, such as:
- Custom and built-in colour themes
- Customizing widget behaviour
- Changing the layout of widgets
- Filtering out entries in some widgets
And more:
- An htop-inspired basic mode
- Expansion, which focuses on just one widget
And more!

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)
Android (arm64)

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, if 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.10.2.tar.gz
tar -xzvf 0.10.2.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 for
# better CPU-specific optimizations. For example:
RUSTFLAGS="-C target-cpu=native" cargo install --path . --locked

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
sudo paru -S bottom-git

# Using yay
sudo 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.10.2/bottom_0.10.2-1_amd64.deb
sudo dpkg -i bottom_0.10.2-1_amd64.deb

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

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

# musl-based
curl -LO https://github.com/ClementTsang/bottom/releases/download/0.10.2/bottom-musl_0.10.2-1_amd64.deb
sudo dpkg -i bottom-musl_0.10.2-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

bottom is available on COPR:

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

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 files are also generated for x86 in the releases page. For example:

curl -LO https://github.com/ClementTsang/bottom/releases/download/0.10.2/bottom-0.10.2-1.x86_64.rpm
sudo rpm -i bottom-0.10.2-1.x86_64.rpm

Gentoo

Available in the official Gentoo repo:

sudo emerge --ask sys-process/bottom

Nix

Available in the nix-community repo:

nix-env -i 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

Formula 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

You can also manually install bottom as a Windows program by going to the latest release and installing via the .msi file.

Pre-built binaries

You can also use the pre-built release binaries:

Latest stable release, built using the release branch
Latest nightly release, built using the main branch at 00:00 UTC daily

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 are packaged with shell auto-completion files for bash, fish, zsh, and Powershell. To install them:

For bash, move btm.bash to $XDG_CONFIG_HOME/bash_completion or /etc/bash_completion.d/.
For fish, move btm.fish to $HOME/.config/fish/completions/.
For zsh, move _btm to one of your $fpath directories.
For PowerShell, add _btm.ps1 to your PowerShell profile.

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

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.

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 one can change as appropriate.

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 opening a question or filing a bug report.

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} ð» ð¦	_{Mahmoud Al-Qudsi} ð»	_Andy ð»	_{Kim Brose} ð»	_{Sven-Hendrik Haase} ð	_{Artem Polishchuk} ð¦ ð	_{Trung LÃª} ð¦ ð
_dm9pZCAq ð¦ ð	_{Lukas Rysavy} ð»	_{Erlend Hamberg} ð»	_{Frederick Zhang} ð»	_pvanheus ð»	_{Zeb Piasecki} ð»	_{Brian Di Palma} ð
_{Lasha Kanteladze} ð	_{Herby Gillot} ð	_{Greg Brown} ð»	_{TotalCaesar659} ð	_{George Rawlinson} ð ð¦	_adiabatic ð	_{Randy Barlow} ð»
_{Patrick Jackson} ð¤ ð	_{Mateusz MikuÅa} ð»	_{Guillaume Gomez} ð»	_shura ð»	_{Wesley Moore} ð»	_xgdgsc ð	_ViridiCanis ð»
_{Justin Martin} ð» ð	_Diana ð»	_{Hervy Qurrotul Ainur Rozi} ð	_{Mike Rivnak} ð	_lroobrou ð»	_{database64128} ð»	_{Chon Sou} ð»
_DrSheppard ð	_{RareÈ Constantin} ð»	_felipesuri ð	_spital ð»	_{Michael Bikovitsky} ð»	_{Dmitry Valter} ð»	_{Twan Stok} ð»
_{Yuxuan Shui} ð»	_{Wenqing Zong} ð»	_{Gabriele Belluardo} ð»	_{Zeb Piasecki} ð»	_wzy ð» ð	_john-s-lin ð	_{Lee Wonjoon} ð» ð
_{David Legrand} ð	_{Michal BryxÃ} ð	_{Raphael Erik Hviding} ð»	_CosmicHorror ð»	_{Ben Woods} ð	_{Stephen Huan} ð»	_{Jason Gwartz} ð

Thanks

This project is very much inspired by gotop, gtop, and htop.
This application was written with many, many libraries, and built on the work of many talented people. This application would be impossible without their work. I used to thank them all individually but the list got too large...
And of course, another round of thanks to all the contributors and package maintainers!

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Getting Started

Competitor Comparisons

Pros of btop

Cons of btop

Code Comparison

Pros of Glances

Cons of Glances

Code Comparison

Summary

Pros of htop

Cons of htop

Code Comparison

Pros of gtop

Cons of gtop

Code Comparison

Key Differences

Use Cases

Pros of ytop

Cons of ytop

Code Comparison

Pros of s-tui

Cons of s-tui

Code Comparison

Convert designs to code with AI

README

bottom (btm)

Table of contents

Features

Support

Official

Unofficial

Installation

Cargo

Arch Linux

Debian / Ubuntu

Exherbo Linux

Fedora / CentOS / AlmaLinux / Rocky Linux

Gentoo

Nix

Snap

Solus

Void

Homebrew

MacPorts

Chocolatey

Scoop

winget

Windows installer

Pre-built binaries

Auto-completion

Usage

Configuration

Troubleshooting

Contribution

Contributors

Thanks

Top Related Projects

Convert designs to code with AI