5 of the Best notify-send Alternatives for Linux

Notification servers, such as notify-send, are a vital part of every desktop Linux distribution. They allow you to receive every status notification from every program currently running in your machine.

This guide shows you some of the most useful notification servers in Linux. We also show how to install them in your machine and send a basic notification message.

Tip: If you are on Windows, here are the ways to manage the notifications in Windows.

How Does notify-send Work?

A notification server such as notify-send is a daemon that prints “status events” from programs currently in the background. It works by listening for a specific type of message from all running processes in your system.

Once it receives a status message, the daemon will draw a small window in your desktop that contains the message that the background process sent, as well as any additional formatting from the daemon.

While most desktop environments today integrate their own notification servers, one key limitation of these is that they are rarely extensible. This can be an issue if you want to run your own custom scripts that will print their status directly to your desktop.

You can address this limitation by installing a third-party notification server. These programs allow you to set custom parameters and formats which often work with existing applications and scripts in your system.

Tip: you can also manage your notifications on your Android phone.

1. Dunst

Dunst is one of the most popular third-party notification servers for Linux. It is a lightweight daemon that uses the original libnotify library for displaying notifications in Xorg. Dunst also aims to improve the original notify-send program by introducing features such as custom colors and window geometry.

Aside from that, it is also possible to extend Dunst through shell scripting. Unlike notify-send, this program allows you to create complex notification rules that only run when certain conditions are met. For example, you can tell Dunst to display a “Battery Warning” notification when your laptop’s charge level drops to 30%.

Install Dunst in Ubuntu by running the following command:

sudo apt install dunst

This program is also available as an installable package in Arch Linux through pacman:

sudo pacman -S dunst

Also install this program on Fedora using the dnf package manager:

sudo dnf install dunst

Test whether Dunst is properly working in your system by running a dunstify command:

dunstify "MakeTechEasier" "Hello world!"

2. Deadd Notification Center

The Deadd Notification Center is an extensive notify-send daemon that attempts to create a unified notification platform for Linux machines. It also uses notify-send to communicate with other programs in your system.

One of the biggest selling points of the Deadd Notification Center is its “overview” panel. This is a temporary pull-up window that can display all of the previous notifications in your system. This is useful if you are constantly away from your computer and want to be updated with certain system events.

The Deadd Notification Center can be installed using an AUR helper in Arch Linux:

sudo yay deadd-notification-center

In Ubuntu, first install its dependencies:

sudo apt install haskell-stack python3-cairo-dev gobject-introspection wget pkg-config build-essential libpython3-dev libdbus-1-dev

Next, download and unpack a copy of the program from its Git repository:

wget https://github.com/phuhl/linux_notification_center/archive/refs/tags/1.7.2.tar.gz
tar xvzf ./1.7.2.tar.gz

Go inside the repository’s directory and run the following commands:

cd linux_notification_center-1.7.2
wget https://github.com/phuhl/linux_notification_center/releases/download/1.7.2/deadd-notification-center
mkdir -p .out
mv deadd-notification-center .out
sudo make install

Run a notify-send command to test whether the daemon works:

notify-send "Hello world!"

3. fnott

Minimal and elegant. Fnott is a modern notification daemon for Wayland-based desktop environments. Unlike the previous entries, this program focuses on making its basic set of features accessible and easy to use.

Fnott gives you a straightforward list of options, such as the ability to change the geometry and colors of the notification window. Aside from that, this program also allows you to embed action buttons and urgency levels.

Similar to the Deadd Notification Center, fnott does not currently exist as a package on most Linux distributions. You need to compile it from source to use it.

To start, first obtain all the dependencies for fnott:

sudo apt install git fontconfig libfontconfig-dev libfreetype-dev libpixman-1 libpixman-1-dev libpng-dev wayland-protocols libwayland-dev libdbus-1-dev meson ninja-build scdoc

Next, clone the program’s repository using Git:

git clone https://codeberg.org/dnkl/fnott.git

Create the build directory for fnott and build it:

cd ./fnott
mkdir -p build/out && cd build/out
meson --buildtype=release
ninja

Run fnott and send your first notification:cm:

./fnott
notify-send "Hello world!"

4. mako

Mako is a notification daemon for Wayland-based desktop environments. However, unlike fnott, it heavily borrows its configuration format and style from Dunst, making it incredibly easy for users to port their configuration files from Xorg to Wayland.

Aside from its compatibility features, mako also stands out with its ability to group notifications under certain “modes.” These are conditional states that you can group your notification windows with where they can inherit certain properties.

Install mako as a package in most Linux distributions. For example, you can run the following command to install the program in Ubuntu:

sudo apt install mako-notifier

Also install mako in Fedora through dnf:

sudo dnf install mako

It is also available as a community package in Arch Linux:

sudo pacman -S mako

Once installed, run the following command to start using mako as a notification daemon:

mako
notify-send "Hello world!"

5. statnot

Statnot is a highly spartan notification daemon for Linux. It aims to create an easy-to-understand way to display status events in X-based window managers such as dwm.

Unlike regular daemons, statnot works by using a window manager’s status bar to display current notifications by actively swapping the regular bar text with a “NOTIFICATION:” alert. This approach makes statnot a great, non-intrusive way to display current status events on a window manager system.

Aside from that, one of the biggest selling points of statnot is that it is easy to configure. In most cases, the statnot daemon only uses a simple shell script that you can customize to behave exactly as you want it to.

Statnot is currently not available as a package on most Linux distributions. You will need to compile this program to use it in your machine.

To start, first install all of its dependencies:

sudo apt install git python3 python3-dbus python3-gi python3-gi-cairo gir1.2-gtk-3.0 libdbus-1-dev make

Clone the program’s repository from the developer’s website:

git clone https://github.com/halhen/statnot.git

Go inside the repository directory and compile the program:

cd statnot
sudo make install

Create your script file, which is what statnot will open to display its notifications. Do that by running the following command:

touch /home/$USER/.statusline.sh

Write a shell script inside it which will serve as a bridge between libnotify and statnot. The following is the default script from the developers that I have partly modified:

#!/bin/sh
 
if [ $# -eq 0 ]; then
echo "This is statnot running!";
else
echo "NOTIFICATION: $1";
fi

Use statnot by either running the following on a terminal or adding it to your Xinit startup script:

statnot &

Good to know: you can learn more about window managers in Linux by installing bspwm.

Frequently Asked Questions

Image credit: Unsplash. All alterations and screenshots by Ramces Red.

Ramces Red - Staff Writer

Ramces is a technology writer that lived with computers all his life. A prolific reader and a student of Anthropology, he is an eccentric character that writes articles about Linux and anything *nix.