# Wired: an X11 notification daemon where every notification is its own window

> Wired is a Rust notification daemon for X11 that draws each notification in a separate window and lays it out with programmable blocks, so the same daemon can show a playlist control with clickable actions or a wide single-line banner. It suits someone who wants their notifications laid out exactly as they want them, and it is X11 only, with no Wayland support.

**Toqozz/wired-notify** — Lightweight notification daemon with highly customizable layout blocks, written in Rust.

- Repository: https://github.com/Toqozz/wired-notify
- Stars: 707 · Forks: 30
- Language: Rust
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/toqozz-wired-notify

## One window per notification, and why that is the design

Wired is a light and fully customizable notification daemon with extensible layout tools, and the README states it is written in Rust.

The feature that defines it is stated almost as an aside: every notification is a different window. The reason given is a complaint, in the author's own words, about stuff only being able to show one notification at a time.

That is a real architectural choice rather than a cosmetic one. A conventional notification daemon draws into a single surface, which means notifications queue, stack, expire and replace each other according to a policy the user cannot influence. Wired instead opens a separate window per notification, which means each one can carry its own layout, its own size, its own position, and its own lifetime, and none of them has to fight the others for a shared surface.

Everything else in the project follows from that. The layout is per notification rather than global, so you position every element how you want it and the wiki's Blocks page carries the details. The layout elements are programmable and interactable, so you can code your own or use layout elements from Wired and from contributors, with the project accepting pull requests. The built-in elements include text blocks which scroll, and backgrounds which reflect state such as paused, active or extended. Layout elements can fire events on click, such as opening a URL.

The mouse story is called out separately as first class. Close, pause and open URLs within a notification with a click, and the README invites issues for more action ideas. The gallery section points at a GitHub issue where other people have posted what they made with it, which is the closest thing to a collection of examples.

## Building from source, and the dependency list that defines the platform

The build section is short, and the dependency line before it is the most informative thing in the README.

```
`rust, dbus, cairo, pango, glib2, x11, xss (for idle support)`
```

That single line is the platform story. X11 with the X Screen Saver extension for idle support, cairo and pango for text rendering through the GTK rendering stack, glib2, and D-Bus for talking to the rest of the desktop. The repository topics say the same thing more bluntly, naming notification, notification-daemon, x11 and wired.

The build itself is a standard cargo build from a clone.

```sh
$ git clone https://github.com/Toqozz/wired-notify.git
$ cd wired-notify
$ cargo build --release
$ ./target/release/wired
```

The Cargo.toml confirms the dependency list in detail, and it explains how the blocks are written. The package is wired at version 0.10.7, edition 2021, authored by Michael Palmos, and it depends on a local wired_derive path crate, which is a procedural macro crate for the block definitions. There is a wired_multilayout.ron file at the top level, and the crate depends on the ron serialization format, which is how the configuration is expressed.

For rendering, the versions line up with the cairo and pango stack, with pangocairo, cairo-rs and cairo-sys-rs at 0.15.x, and there is a separate group for SVG handling with usvg, resvg and tiny-skia, which is how a block can draw vector artwork.

The X11 handling is winit at 0.29 with raw-window-handle, and the dbus crates are dbus and dbus-crossroads, the latter being a framework for writing D-Bus clients in a type safe way. xdg, getopts, chrono, image, serde, serde_json, notify, bitflags and home-dir fill out the rest, and the notify crate is what delivers the notifications themselves.

## Four installation routes, and the two config files that show the layout model

Wired is packaged for several distributions, and the README covers each one, but the interesting part of the distribution story is that the Nix route carries the configuration with it.

On Arch, the package is on the AUR.

```sh
$ yay -S wired
```

There is also a -git version which tracks master, and the README warns about it: no guarantees are made about stability on the master branch, though the author does appreciate help finding bugs before they make it to a release.

```sh
$ yay -S wired-git
```

The Nix route is the more capable one, because flake support was added to Nix in version 2.4, and as of Nix 2.8 you must enable the nix-command and flakes experimental features. Wired can be run directly from the repository.

```sh
nix run 'github:Toqozz/wired-notify'
```

Or installed to your user profile, with the note that the systemd service will not be available if installed with this method.

```sh
# note: the systemd service will not be available if installed with this method
nix profile install 'github:Toqozz/wired-notify'
```

That caveat is the one thing to remember about the Nix path, and it is the reason the systemd file matters. A wired.service file sits in the root of the repository, and copying it to /usr/local/lib/systemd/user/wired.service, or your distro equivalent, is what gives you a unit you can enable.

```sh
$ systemctl enable --now --user wired.service
```

The other recommended way to start it is even simpler, putting the binary in your autostart script.

```
/path/to/wired &
```

NetBSD has the package in the official repositories, and the RHEL family has an installer.sh script that needs DNF and sudo.

```sh
$ pkgin install wired-notify
```

```sh
$ cd wired-notify
$ chmod +x installer.sh
$ sudo ./installer.sh
```

The two config files in the repository root, wired.ron and wired_multilayout.ron, are the quickest way to understand what a Wired layout actually is before reading the wiki.

## Writing your own block, and the wiki carrying the real documentation

The README is candid that the documentation lives elsewhere. Configuration settings are on the Config wiki page, and the wiki is where you find everything else you need to know about using Wired.

The extension model is described in a section titled Making your own elements, and the pitch is that making your own layout elements is designed to be as easy as possible, so that anybody who knows basic Rust should be able to make a layout element. There is a detailed tutorial on making and adding a layout element to Wired on the wiki.

That is a claim worth taking at face value in one respect and discounting in another. The repository layout supports the claim that the block model is code rather than configuration, with a src directory, a wired_derive directory that is a separate local crate, and the .ron configuration files that reference blocks by name. A block is a Rust type with a derive macro, and the configuration selects and arranges them. So extending it is genuinely a programming task, and the barrier for a user is a compile step rather than a schema edit.

The second half of the claim, that basic Rust is enough, is the part to be careful about, because the block has to talk to the daemon, receive mouse events, and render. The first class mouse actions requirement means a block is not a passive drawing, it is an interactive object with a hit region and a set of actions.

For a user who wants to see what others have built, the gallery issue linked in the README is the best source, and the three animated images in the README give a sense of the range, with a music player control, a simple notification, and a horizontal layout.

## The X11 constraint, and what that rules out

The hard limit of this project is the one that is easiest to overlook, because nothing in the README says the word Wayland anywhere. The dependency list is X11, cairo, pango, glib2 and xss, the topics are x11, notification and notification-daemon, and the Cargo.toml pulls in the x11 crate at 2.18.1 with the xlib and xss features enabled.

The consequence is straightforward. Wired is a notification daemon for an X11 session. On a Wayland session, where the notification model is the freedesktop portal rather than a daemon on the display server, this project does not apply. The closest alternative on Wayland is a portal based client, and a user who has already moved their desktop to Wayland should look there rather than try to adapt this.

The second limitation is that Wired is a daemon in the strict sense, which means it has to be running before the notifications arrive, and the recommended way to achieve that is the autostart entry or the systemd user unit. On a session that starts a lot of applications, a daemon that starts late misses the first notifications of the login.

The third is the one the README itself names, the difference between the release and master. The AUR -git package tracks master with no stability guarantees, and the project is explicit that the master branch is where bugs are found before they reach a release. That is normal for a project of this size, but it does mean the choice of channel is a real decision rather than a detail.

The release history bears that out. The versions are 0.10.7 from 2026-07-25, 0.10.6 from 2024-06-05 and 0.10.5 from 2024-02-17, so two releases in the first half of 2024, then a long gap, then one in July 2026. The last push was on 2026-10-12, so work is continuing between releases, and a project with a two year gap between tags and a low 0.x version number is a project to watch rather than to depend on a schedule from. The licence is MIT, and the repository is under the Toqozz organisation.

## Conclusion

Wired fits an X11 user whose notifications are important enough to deserve their own layout, who wants clickable actions inside a notification, and who is willing to write a block in Rust when the built-in ones do not fit. It does not fit a Wayland user, since the dependency list is X11, cairo, pango and glib2 and the project topics are X11, and it does not fit someone who wants a stock desktop notification. Before adopting it, read the Config and Blocks wiki pages, because the configuration format and the block model are documented there rather than in the repository, and check the two config files at the top of the tree, wired.ron and wired_multilayout.ron, to see what a real layout looks like.

## FAQ

### How do I build and run Wired from source?

Clone the repository, then run cargo build --release and launch ./target/release/wired. The build needs rust, dbus, cairo, pango, glib2, x11 and xss, where xss is for idle support.

### Does Wired work on Wayland?

The documented dependencies are rust, dbus, cairo, pango, glib2, x11 and xss, and the repository topics name x11, so Wired targets X11 sessions. The README does not describe a Wayland path.

### How do I make my own layout element in Wired?

Layout elements are written in Rust rather than configured as data, with a wired_derive crate providing the procedural macros and the blocks selected by name from a .ron configuration file. The README points to a detailed tutorial on making and adding a layout element in the wiki, and says that anybody who knows basic Rust should be able to write one.

### How do I install Wired on Arch Linux?

The package is on the AUR, installed with yay -S wired. There is also a -git variant that tracks the master branch, and the README warns that no stability guarantees are made for it.

## Sources

- [Issues](https://github.com/Toqozz/wired-notify/issues)
- [License: MIT](https://github.com/Toqozz/wired-notify/blob/master/LICENSE)
- [README](https://github.com/Toqozz/wired-notify/blob/master/README.md)
- [Releases](https://github.com/Toqozz/wired-notify/releases)
- [Toqozz/wired-notify on GitHub](https://github.com/Toqozz/wired-notify)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/toqozz-wired-notify