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.

A screenshot of a text table that shows a segment of the libnotify standard.
Image source: Galago Project

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.

A screenshot of a toast notification in Gnome.

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.

A screenshot of a toast notification in Gnome that shows a simple custom message.

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.

A screenshot of a simple Dunst notification.

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%.

A screenshot of a Dunst notification showing critical information.

Install Dunst in Ubuntu by running the following command:

sudo apt install dunst
A terminal screenshot of the Dunst installation process.

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!"
A screenshot of a Dunst notification showing a custom message.

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.

A screenshot of a Deadd notification window showing a simple message.

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.

A screenshot of the Deadd notification center.

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
A terminal window screenshot that shows the dependency installation process for Deadd.

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
A screenshot of a terminal window that shows the Deadd installation process.

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

notify-send "Hello world!"
A screenshot of a Deadd notification window showing a custom message.

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.

An image of the basic fnott notification window.

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.

An image of a fnott notification window showing a critical battery message.

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
A terminal window showing the installation of dependencies for fnott.

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
A terminal window showing the compilation process for fnott.

Run fnott and send your first notification:cm:

notify-send "Hello world!"
An image of a fnott notification window showing a custom message.

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.

An image of the mako notification window showing a simple message.

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.

An image of the mako notification window showing a critical battery message.

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
A terminal window showing the installation process for mako.

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:

notify-send "Hello world!"
An image of the mako notification window showing a custom message.

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.

A section of a screenshot of dwm running statnot.

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.

A terminal window showing a sample status line script for statnot.

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
A terminal window showing the dependency installation process for statnot.

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
A terminal window showing the installation process for statnot.

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:

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

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

statnot &
A terminal window showing statnot running and showing a custom notification.

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

Frequently Asked Questions

My notify-send notifications stopped working after installing Dunst.

This issue is most likely due to your system not being able to load Dunst properly after installation. One quick way to solve this issue is to either log out of your current session or restart your computer.

Mako is still using the notify-send notifications window.

The most common cause for this issue is a conflict between libnotify and dbus. Since mako is a Wayland-specific daemon, it does not need the libnotify library.

You can fix this issue by removing libnotify from your system: sudo apt remove libnotify.

Statnot does not seem to run in my machine.

This is most likely happening due to a conflict between statnot and your system's notify-send daemon. You can fix this issue by killing your default notification server using the following:
pkill notification-daemon-name; statnot &.

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

Ramces Red

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.

Subscribe to our newsletter!

Our latest tutorials delivered straight to your inbox