[opensourcedex]

MangoHud is a free, open source monitoring & observability project written in C and released under MIT. It has 9,041 GitHub stars, 428 forks and 336 open issues, and was last pushed 39 hours ago. On this registry it ranks #55 of 191 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available.

What is MangoHud?

MangoHud is an MIT-licensed Vulkan and OpenGL overlay written in C that draws FPS, frametimes, temperatures and CPU/GPU load on top of Linux applications, built for Linux gamers, benchmarkers and anyone profiling a GPU workload.

What it is

MangoHud is a monitoring overlay that hooks into Vulkan and OpenGL applications on Linux and renders a performance readout over the frame. It reports frame rate, frametimes, temperatures and CPU and GPU load, and it can also log those figures to disk. The project is written in C, distributed under the MIT licence, maintained in the open on GitHub, and its topics list places it in Linux benchmarking and monitoring: benchmarking, hud, linux, monitoring, opengl, vulkan.

The concrete problem it solves is fragmentation of performance telemetry across the Linux graphics stack. The same metrics are reachable in different ways depending on whether an application renders through Vulkan or OpenGL, whether the session runs under X11 or Wayland, and which GPU vendor and driver are in use; the README keeps a dedicated "Metrics support by GPU vendor/driver" section for exactly that reason. MangoHud presents one overlay and one configuration surface across those combinations, and extends the same data into logging, local plotting through mangoplot, and online visualization on FlightlessMango.com. That replaces the situation where a player or reviewer depends on whatever readout an individual application happens to provide, or on no readout at all.

Key capabilities

  • Draws a performance overlay over Vulkan and OpenGL applications, reporting FPS, frametimes, temperatures, and CPU/GPU load.
  • Configures behavior through the environment variables MANGOHUD_CONFIG, MANGOHUD_CONFIGFILE, and MANGOHUD_PRESETSFILE.
  • Logs FPS data, then visualizes it locally with mangoplot or online at FlightlessMango.com.
  • Provides keybindings for toggling the display, with separate X11 and Wayland paths governed by the with_x11 and with_wayland meson options.
  • Handles Vsync, with OpenGL Vsync and Vulkan Vsync documented as distinct cases.
  • Collects NVIDIA metrics through NVML or XNVCtrl, selected with the with_nvml and with_xnvctrl meson options, where XNVCtrl covers older GPUs.
  • Builds optional components mangoapp and mangohudctl through meson options, and ships a workarounds section for applications that misbehave with the layer enabled.

Who uses it and how

  • Linux gamers running Vulkan or OpenGL titles who want a continuous on-screen frame and thermal readout without modifying the game.
  • Benchmarkers and reviewers who record frame data through FPS logging and compare runs using mangoplot or the FlightlessMango.com visualization.
  • NVIDIA users on Wayland, who rely on the NVML-enabled build, and users of older NVIDIA cards, who need the XNVCtrl build.
  • Users on systemd and non-systemd distributions alike, since sd-bus resolves to libsystemd-dev or elogind, and the optional D-Bus dependency gates the media features.
  • Multilib users, because the project documents 32-bit builds on 64-bit distributions with distro-specific libdir values such as lib32 on Arch and lib/i386-linux-gnu on Debian-based systems.

Getting started

Clone the repository with git clone --recurse-submodules, then build and install with meson build followed by ninja -C build install, or run ./build.sh build, which installs into ./build/release; pre-packaged binaries are available from GitHub releases, Arch, Debian and Ubuntu, Fedora, Solus, openSUSE, and Flatpak.

How it compares

No comparable tools are named in the facts available for this page, and no list of paid products it replaces is provided, so MangoHud stands alone in this registry. That reflects the source material rather than a claim that nothing similar exists.

When to use it — and when not to

Building from source pulls a long dependency list: gcc and g++, meson 0.54 or newer, ninja, glslang, the Vulkan loader, libGL/libEGL, GBM, libdrm, libcap, sd-bus through libsystemd-dev or elogind, yaml-cpp, X11, wayland-client, xkbcommon, and Python 3 Mako; XNVCtrl and D-Bus are optional and can be disabled at build time. Metric coverage is not uniform, since it varies by GPU vendor and driver, and the README defers to a dedicated compatibility section rather than promising a full set everywhere. The project carries 336 open issues, and it targets Linux only, so users on Windows or macOS, or those wanting a zero-dependency install, should look elsewhere.

project readme (upstream, from github) — read inline

MangoHud

A Vulkan and OpenGL overlay for monitoring FPS, temperatures, CPU/GPU load and more.

Example gif showing a standard performance readout with frametimes

Installation - Build From Source

If you wish to compile MangoHud to keep up to date with any changes - first clone this repository and cd into it:

git clone --recurse-submodules https://github.com/flightlessmango/MangoHud.git
cd MangoHud

Using meson to install "manually":

meson build
ninja -C build install

By default, meson should install MangoHud to /usr/local. Specify install prefix with --prefix=/usr if desired. Add -Dappend_libdir_mangohud=false option to meson to not append mangohud to libdir if desired (e.g. /usr/local/lib/mangohud).

To install 32-bit build on 64-bit distro, specify proper libdir: lib32 for Arch, lib/i386-linux-gnu on Debian-based distros. RPM-based distros usually install 32-bit libraries to /usr/lib and 64-bit to /usr/lib64. You may have to change PKG_CONFIG_PATH to point to correct folders for your distro.

CC="gcc -m32" \
CXX="g++ -m32" \
PKG_CONFIG_PATH="/usr/lib32/pkgconfig:/usr/lib/i386-linux-gnu/pkgconfig:/usr/lib/pkgconfig" \
meson build32 --libdir lib32
ninja -C build32 install

Dependencies

Install necessary development packages.

  • gcc, g++
  • or gcc-multilib, g++-multilib for 32-bit support
  • meson >=0.54
  • ninja (ninja-build)
  • glslang
  • Vulkan loader (libvulkan-dev)
  • libGL/libEGL (libglvnd, libgl-dev, libegl-dev, mesa-common-dev, mesa-libGL-devel etc)
  • GBM (libgbm-dev)
  • libdrm (libdrm-dev)
  • libcap (libcap-dev)
  • sd-bus (libsystemd-dev, or elogind on non-systemd distributions)
  • yaml-cpp (libyaml-cpp-dev)
  • X11 (libx11-dev)
  • XNVCtrl (libxnvctrl-dev), optional, use -Dwith_xnvctrl=disabled option with meson to disable
  • D-Bus (libdbus-1-dev), optional, use -Dwith_dbus=disabled option with meson to disable
  • wayland-client
  • xkbcommon

Python 3 libraries:

  • Mako (python3-mako or install with pip)

If distro's packaged meson is too old and gives build errors, install newer version with pip (python3-pip).

Meson options

Option Default Description
with_nvml enabled Required for NVIDIA GPU metrics on wayland
with_xnvctrl enabled Required for NVIDIA GPU metrics on older GPUs
with_x11 enabled Required for keybinds on x11
with_wayland enabled Required for keybinds on wayland
with_dbus enabled Required for using the media features
mangoapp false Includes mangoapp
mangohudctl false Include mangohudctl
tests auto Includes tests
mangoplot true Includes mangoplot

Building with build script

You can also use build.sh script to do some things automatically like install dependencies, if distro is supported but it usually assumes you are running on x86_64 architecture.

To just build it, execute:

./build.sh build

You can also pass arguments to meson:

./build.sh build -Dwith_xnvctrl=disabled

Resulting files will be install to ./build/release folder.

If you have compiled MangoHud from source, to install it, execute:

./build.sh install

You can then subsequently uninstall MangoHud via the following command

./build.sh uninstall

To tar up the resulting binaries into a package and create a release tar with installer script, execute:

./build.sh package release

or combine the commands, although package should also call build if it doesn't find the built libs:

./build.sh build package release

If you have built MangoHud before and suddenly it fails, you can try cleaning the build folder, execute:

./build.sh clean

Currently it just does rm -fr build and clears subprojects.

NOTE: If you are running an Ubuntu-based, Arch-based, Fedora-based, or openSUSE-based distro, the build script will automatically detect and prompt you to install missing build dependencies. If you run into any issues with this please report them!

Installation - Pre-packaged Binaries

GitHub releases

If you do not wish to compile anything, simply download the file under Releases, extract it, and from within the extracted folder in terminal, execute:

./mangohud-setup.sh install

Arch-based distributions

If you are using an Arch-based distribution, install mangohud and lib32-mangohud from the extra/multilib repository. mangohud-git and lib32-mangohud-git are available on the AUR to be installed via your favourite AUR helper. These can help fix issues with the hud not activating when using stable releases from pacman!

If you are building it by yourself, you need to enable multilib repository, by editing pacman config:

sudo nano /etc/pacman.conf

and uncomment:

#[multilib]
#Include = /etc/pacman.d/mirrorlist

then save the file and execute:

sudo pacman -Syy

Debian, Ubuntu

If you are using Debian 11 (Bullseye) or later, Ubuntu 21.10 (Impish) or later, or distro derived from them, to install the MangoHud package, execute:

sudo apt install mangohud

Optionally, if you also need MangoHud for 32-bit applications, on Debian you can execute:

sudo apt install mangohud:i386

The 32-bit package is not available on Ubuntu.

Fedora

If you are using Fedora, to install the MangoHud package, execute:

sudo dnf install mangohud

Solus

If you are using Solus, to install MangoHud simply execute:

sudo eopkg it mangohud

openSUSE

If you run openSUSE Leap or Tumbleweed you can get Mangohud from the official repositories. There are two packages, mangohud for 64bit and mangohud-32bit for 32bit application support. To have Mangohud working for both 32bit and 64bit applications you need to install both packages even on a 64bit operating system.

sudo zypper in mangohud mangohud-32bit

Leap doesn't seem to have the 32bit package.

Leap 15.2

sudo zypper addrepo -f https://download.opensuse.org/repositories/games:tools/openSUSE_Leap_15.2/games:tools.repo
sudo zypper install mangohud

Leap 15.3

sudo zypper addrepo -f https://download.opensuse.org/repositories/games:tools/openSUSE_Leap_15.3/games:tools.repo
sudo zypper install mangohud

Flatpak

If you are using Flatpaks, you will have to add the Flathub repository for your specific distribution, and then, to install it, execute:

For flatpak:

flatpak install org.freedesktop.Platform.VulkanLayer.MangoHud

To enable MangoHud for all Steam games:

flatpak override --user --env=MANGOHUD=1 com.valvesoftware.Steam

Normal usage

To enable the MangoHud overlay layer for Vulkan and OpenGL, run :

mangohud /path/to/app

For Lutris games, go to the System options in Lutris (make sure that advanced options are enabled) and add this to the Command prefix setting:

mangohud

For Steam games, you can add this as a launch option:

mangohud %command%

Or alternatively, add MANGOHUD=1 to your shell profile (Vulkan only).

OpenGL

OpenGL games may also need dlsym hooking, which is now enabled by default. Set th

readme truncated — read the full docs on github

Frequently asked questions

Is MangoHud free to use?

MangoHud 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 MangoHud do?

A Vulkan and OpenGL overlay for monitoring FPS, temperatures, CPU/GPU load and more.

What is MangoHud written in?

MangoHud is primarily written in C. Its source is publicly available at https://github.com/flightlessmango/MangoHud, and it has 9,041 GitHub stars.