Poor man's workspace indicator for Waybar

[matbme]

Now that v0.1.6 is out with niri msg workspaces, we have the tools to write a (somewhat hacky) workspace indicator! I'll share how I implemented a simple indicator for Waybar.

First and foremost, this is how it turned out (see top-left):

First, we will need a script that parses the output of msg workspaces. Save it somewhere inside your home dir (e.g. ~/niri-workspaces.sh):

#!/bin/bash

set -e

active=""
inactive=""

workspace_str=""

monitor=$1

reading_output=0
while read -r line; do
	if [ $reading_output -eq 0 ] && [ "$(echo "$line" | cut -d ' ' -f 2)" = "\"$monitor\":" ]; then
		reading_output=1
		continue
	elif [ $reading_output -eq 1 ]; then
		if [ -z "$line" ]; then
			printf "%s" "$workspace_str"
			exit
		fi

		if [ "$(echo "$line" | head -c 1)" = '*' ]; then
			workspace_str="${workspace_str}${active}  "
		else
			workspace_str="${workspace_str}${inactive}  "
		fi
	fi
done <<<"$(niri msg workspaces)"

printf "%s" "$workspace_str"

Since we're not fancy enough to write a custom module, we also need a script to wrap niri actions and call pkill on waybar with a signal (I saved in myhome dir as ~/exec_and_signal.sh):

#!/bin/sh

niri msg action $1
pkill -SIGRTMIN+8 waybar

Now, it's time to configure waybar:

...
    "modules-left": [
        "custom/workspaces",
        ...
    ],
...
    "custom/workspaces": {
        "exec": "~/niri-workspaces.sh \"$WAYBAR_OUTPUT_NAME\"",
        "signal": 8
    },

Don't forget to restart waybar: systemctl --user restart waybar.service

Lastly, open your niri config and replace all workspace-related binds with our wrapper:

    Mod+1 { spawn "~/exec_and_signal.sh" "focus-workspace 1"; }
    Mod+2 { spawn "~/exec_and_signal.sh" "focus-workspace 2"; }
    Mod+3 { spawn "~/exec_and_signal.sh" "focus-workspace 3"; }
    Mod+4 { spawn "~/exec_and_signal.sh" "focus-workspace 4"; }
    Mod+5 { spawn "~/exec_and_signal.sh" "focus-workspace 5"; }
    Mod+6 { spawn "~/exec_and_signal.sh" "focus-workspace 6"; }
    Mod+7 { spawn "~/exec_and_signal.sh" "focus-workspace 7"; }
    Mod+8 { spawn "~/exec_and_signal.sh" "focus-workspace 8"; }
    Mod+9 { spawn "~/exec_and_signal.sh" "focus-workspace 9"; }

Aaaaand now you should have a (very, very hacky) workspace switcher! :)

[YaLTeR]

Hey, that's pretty cool! Just keep in mind that the human-readable niri msg output is not guaranteed to be stable, in contrast to the niri msg --json output. :)

[matbme]

In my infinite wisdom I tried to use niri msg workspaces --json which didn't work, so I assumed json output wasn't implemented yet 🙃 .

The first script is now much simpler (and POSIX compatible):

#!/bin/sh

set -e

monitor=$1

active=""
inactive=""

workspace_str=""

msg_out="$(niri msg -j workspaces | jq ".[] | select(.output == \"$monitor\") | .is_active")"
for ws in $msg_out; do
	if "$ws"; then
		workspace_str="${workspace_str}${active}  "
	else
		workspace_str="${workspace_str}${inactive}  "
	fi
done

printf "%s" "$workspace_str"

Thanks for the tip and your amazing work on Niri!

[nebulosa2007]

My edits and improvements:
~/.config/waybar/modules/workspaces.sh

#!/usr/bin/env bash

case "$1" in 
focus-workspace)
    niri msg action "$@" && pkill -SIGRTMIN+8 waybar;;
up)
    niri msg action focus-workspace-up && pkill -SIGRTMIN+8 waybar;;
down)
    niri msg action focus-workspace-down && pkill -SIGRTMIN+8 waybar;;
*)
    glyphs=""
    workspace_str=" " 
    for ws in $(niri msg -j workspaces | jq ".[] | select(.output == \"$1\") | .is_active"); do
        workspace_str="$workspace_str$( if "$ws"; then
                 echo "<big><span color='#1793d1'>${glyphs:0:1}</span></big>";
            else echo "<small>${glyphs:1:1}</small>"; fi)  "
    done
    name=$(niri msg -j workspaces | jq -r ".[] | select(.output == \"$1\" and .is_active == true) | .name")
    echo -e "{\"text\":\"${workspace_str}\", \"tooltip\":\"Active workspace name: ${name}\"}"
esac

.config/waybar/config.jsonc

    "custom/niri_workspaces": {
        "format": "{}",
        "interval": 2,
        "return-type": "json",
        "exec": "$HOME/.config/waybar/modules/workspaces.sh \"$WAYBAR_OUTPUT_NAME\"",
        "on-click": "fuzzel",
        "on-scroll-up": "$HOME/.config/waybar/modules/workspaces.sh up",
        "on-scroll-down": "$HOME/.config/waybar/modules/workspaces.sh down",
        "signal": 8
    },

That's all, ~/exec_and_signal.shdoesn't need anymore.

At niri config you can set:

Mod+1 { spawn "~/.config/waybar/modules/workspaces.sh" "focus-workspace" "1"; }
// or just (will update in 2 secs)
Mod+2 { focus-workspace 2; }

Here the result:

On scroll up or down - switching to next or previous workspace, on click - launch fuzzel. Font

[lpnh]

I shamelessly stole the code from both nebulosa2007 and matbme and combined them to achieve a simple and straightforward solution. Here's the result:

~/.config/waybar/modules/niri-workspaces.sh

#!/usr/bin/env bash

case "$1" in 
focus-workspace)
    niri msg action "$@" && pkill -SIGRTMIN+8 waybar;;
*)
	set -e

	monitor=$1

	active=""
	inactive=""

	workspace_str=""

	msg_out="$(niri msg -j workspaces | jq ".[] | select(.output == \"$monitor\") | .is_active")"
	for ws in $msg_out; do
		if "$ws"; then
			workspace_str="${workspace_str}${active}  "
		else
			workspace_str="${workspace_str}${inactive}  "
		fi
	done

	printf "%s" "$workspace_str"
esac

~/.config/waybar/config.jsonc

    "modules-left": [
        "custom/workspaces",
    ],

    "custom/workspaces": {
        "exec": "$HOME/.config/waybar/modules/niri-workspaces.sh \"$WAYBAR_OUTPUT_NAME\"",
        "signal": 8
    },

~/.config/niri/config.kdl

Mod+1 { spawn "~/.config/waybar/modules/niri-workspaces.sh" "focus-workspace" "1"; }
Mod+2 { spawn "~/.config/waybar/modules/niri-workspaces.sh" "focus-workspace" "2"; }
Mod+3 { spawn "~/.config/waybar/modules/niri-workspaces.sh" "focus-workspace" "3"; }

[freijon]

Just learned about this discussion after I implemented everything from scratch. I'm using nushell as my shell & preferred scripting tool, so might be a bit niche, but if anyone wants to use it, feel free:

~/.config/waybar/modules/get-niri-workspaces.nu

#!/usr/bin/nu

let out = {
  text: "",
  alt: "none",
  tooltip: "",
  class: "none" 
}

loop {
  sleep 1sec;
  print (
    $out | update text (
      niri msg -j workspaces
        | from json
        | each { |ws| if $ws.is_active { "" } else { "" } } | str join ' ')
        | to json -r
  )
}

~/.config/waybar/modules/get-niri-focused-window.nu

#!/usr/bin/nu

let out = {
  text: "",
  alt: "none",
  tooltip: "",
  class: "none" 
}

loop {
  sleep 1sec;
  let window = niri msg -j focused-window | from json;
  if $window == null { print ($out | to json -r) } else {
    print (
      $out | update text (
        $"($window.app_id): ($window.title)"
      ) | to json -r
    )
  }
}

and finally in ~/.config/waybar/config.jsonc

    "modules-left": [
        "custom/niri-workspaces",
        "custom/niri-focused-window"
    ],
    "custom/niri-workspaces": {
        "return-type": "json",
        "max-length": 40,
        "escape": true,
        "exec": "$HOME/.config/waybar/modules/get-niri-workspaces.nu"
    },
    "custom/niri-focused-window": {
        "return-type": "json",
        "max-length": 120,
        "escape": true,
        "exec": "$HOME/.config/waybar/modules/get-niri-focused-window.nu",
        "format": "       {}"
    },

[lpnh]

Alright, this is getting fun. I was planning to translate the script to nushell this weekend, but now that freijon has set the bar so high, there's no point in just translating it. Instead, I've made some tweaks to their scripts to meet my own needs and give it a personal touch. Note: no need to change niri's default config.

~/.config/waybar/modules/workspaces.nu

#!/usr/bin/nu

def main [output_name] {
  loop {
    sleep 1sec

    print (
      niri msg -j workspaces
        | from json
        | where output == $output_name
        | each {|ws| if $ws.is_active { '󰪥' } else { '󰄰' } }
        | str join " "
    )
  }
}

~/.config/waybar/modules/window.nu

#!/usr/bin/nu

let out = {
  text: "",
  tooltip: ""
}

loop {
  sleep 1sec

  let fw = niri msg -j focused-window | from json

  print (
    $out
    | try { update text $fw.title | update tooltip $"($fw.title) | ($fw.app_id)" }
    | to json -r
  )
}

~/.config/waybar/config.jsonc

    "modules-left": [
        "custom/workspaces",
        "custom/window"
    ],
    "custom/workspaces": {
        "exec": "$HOME/.config/waybar/modules/workspaces.nu \"$WAYBAR_OUTPUT_NAME\""
    },
    "custom/window": {
        "return-type": "json",
        "max-length": 20,
        "escape": true,
        "exec": "$HOME/.config/waybar/modules/window.nu",
        "format": "<i>{}</i>"
    },

Result:

edit: refactor scripts to make them more idiomatic

[LunarEclipse363]

Inspired by this but in Fish:

~/.config/waybar/modules/workspaces.fish

#!/usr/bin/env fish

while true
    sleep 0.2s

    niri msg --json workspaces \
        | jq -r ".[] | if .is_active then \"󰪥\" else \"󰄰\" end" \
        | string join " "
end

~/.config/waybar/modules/window.fish

#!/usr/bin/env fish

while true
    sleep 0.2s

    niri msg --json focused-window \
        | jq -c 'if type != "object" then { "text": "", "tooltip": "" } else { "text": "\(.app_id): \(.title)", "tooltip": .app_id } end'
end

~/.config/waybar/config.jsonc

    "modules-left": [
        "custom/start",
        "custom/workspaces",
        "custom/window"
    ],
    "custom/workspaces": {
        "exec": "$HOME/.config/waybar/modules/workspaces.fish \"$WAYBAR_OUTPUT_NAME\"",
        "format": " {} "
    },
    "custom/window": {
        "return-type": "json",
        "max-length": 40,
        "escape": true,
        "exec": "$HOME/.config/waybar/modules/window.fish",
        "format": "<i> {} </i>"
    },

[YaLTeR]

Nice bar style lol

[lpnh]

@LunarEclipse363 thanks for sharing! I'm switching to Fish now, so your code was very handy. If you don't mind, I'll share a version here that splits the workspaces according to their output.

#!/usr/bin/env fish

set output_name $argv[1]

while true
    sleep 1s

    niri msg --json workspaces \
    | jq -r ".[] | select(.output == \"$output_name\") | if .is_active then \"󰪥\" else \"󰄰\" end" \
    | string join " "
end

[rustysec]

would have been awesome to actually find any of this before rolling my own, but way less cool, version:

#!/usr/bin/env node

const { spawnSync } = require('child_process');

let output = process.argv[2]

let { stdout, stderr } = spawnSync('niri', ['msg', '-j', 'workspaces'])

let items = JSON.parse(stdout.toString())
    .filter(item => item.output == output)
    .map(item => {
        if (item.is_active) {
            return `(${item.idx})`
        } else {
            return ` ${item.idx} `
        }
    })
    .join(' | ');

console.log(`${items}`)

implementation is very similar, with a waybar spawned for each detected display.

[lost-melody]

I wish I'd have seen this topic before reinventing my own ones... 😅

I was searching for ways to "subscribe" Niri's window/workspace change events so that scripts are only executed when something (focused window, active workspace) actually changes. But now it seems that we could only refresh our waybar modules by executing niri msg repeatedly.

I think we could implement an event system by printing messages to stdout on events emitted:

> niri msg -j subscribe focus-window,focus-workspace
{"event":"focus-window","data":{"app_id":"firefox"}}\n
{"event":"focus-workspace","data":{"monitor":"eDP-1"}}\n
...

or by binding actions to events (like keybindings):

// config.kdl
events {
  focus-window { spawn "pkill" "-SIGRTMIN+1" "waybar"; }
  focus-workspace { spawn "pkill" "-SIGRTMIN+2" "waybar"; }
}

screenshots of my waybar

[YaLTeR]

There will be an event stream IPC.

[coyotle]

Is there a way to do something similar for keyboard layout?

[fengints]

How about adding one of the examples somewhere to the docs as a temporary solution for the version?

[miku4k]

contributing my own vertical solution here in bash:

script:

#!/usr/bin/env bash
[[ -z $NIRI_SOCKET ]] && exit 1

while true; do
    icons="$(niri msg --json workspaces | \
        jq -c 'if .[].is_active then "󰪥" else "󰄰" end' | \
        awk '{ printf "%s\\n", $0 }' | \
        tr -d \" | \
        sed 's/.\{2\}$//')"
    echo "\"$icons\"" | jq -c '{ text: "\(.)" }'
    sleep 1
done

waybar config:

"modules-left": [ "custom/niri-workspaces" ],
"custom/niri-workspaces": {
  "exec": "</path/to/script>",
  "return-type": "json"
},

result:

[svenwltr]

I am using some UTF-8 digits with circles to show the workspace numbers, but still be able to highlight the current one:

#!/usr/bin/env bash

set -e

monitor=$1

niri msg -j workspaces \
    | jq -cr '
        ["⓪", "①", "②", "③", "④", "⑤", "⑥", "⑦", "⑧", "⑨", "⑩"] as $map
        | map(
            select(.output == "'$monitor'")
            | if(.is_active) then $map[.idx] else .idx end
        ) | join(" ")
    '

[freijon]

Nice. Have you considered using negative circled numbers? e.g. ➁ for inactive / ➋ for active

[svenwltr]

Good idea. The script would look like this then:

#!/usr/bin/env bash

set -e

monitor=$1

niri msg -j workspaces \
    | jq -cr '
        ["⓪", "➊", "➋", "➌", "➍", "➎", "➏", "➐", "➑", "➒", "➓"] as $active
        | ["⓪", "①", "②", "③", "④", "⑤", "⑥", "⑦", "⑧", "⑨", "⑩"] as $inactive
        | map(
            select(.output == "'$monitor'")
            | if(.is_active) then $active[.idx] else $inactive[.idx] end
        ) | join(" ")
    '

But these numbers are actually too small for my eyes, I am not just putting parentheses around it:

#!/usr/bin/env bash

set -e

monitor=$1

niri msg -j workspaces \
    | jq -cr '
        map(
            select(.output == "'$monitor'")
                | if(.is_active) then "(\(.idx))" else " \(.idx) " end
        ) | join(" ")
    '

[YaLTeR]

Hi everyone, I just merged the event stream IPC, so latest git niri will work together with my Waybar workspaces PR: Alexays/Waybar#3551

Or you can write a custom script using the event stream IPC to avoid polling, for example:

Details

#!/usr/bin/python3

import json
import os
import sys
from socket import AF_UNIX, SHUT_WR, socket

niri_socket = socket(AF_UNIX)
niri_socket.connect(os.environ["NIRI_SOCKET"])
file = niri_socket.makefile("rw")

file.write('"EventStream"')
file.flush()
niri_socket.shutdown(SHUT_WR)

output = None
if len(sys.argv) > 1:
    output = sys.argv[1]

workspaces = {}


def print_workspaces():
    vals = workspaces.values()
    if output is not None:
        vals = filter(lambda ws: ws["output"] == output, vals)

    vals = sorted(vals, key=lambda ws: ws["idx"])
    text = "\n".join(("󰪥" if ws["is_active"] else "󰄰" for ws in vals))
    print(json.dumps({"text": text}), flush=True)


for line in file:
    event = json.loads(line)

    if changed := event.get("WorkspacesChanged"):
        workspaces = {ws["id"]: ws for ws in changed["workspaces"]}
        print_workspaces()
    elif activated := event.get("WorkspaceActivated"):
        focused = activated["focused"]
        ws_output = workspaces[activated["id"]]["output"]
        for ws in workspaces.values():
            got_activated = ws["id"] == activated["id"]
            if ws["output"] == ws_output:
                ws["is_active"] = got_activated
            if focused:
                ws["is_focused"] = got_activated
        print_workspaces()

[mastoca]

Here's my ~/.config/waybar/config for waybar. It works very nicely. I grabbed and tweaked samples from the PR. Adding here as it may be hard to read in the PR on where it fits.

    "modules-left": ["niri/workspaces", "wlr/taskbar"],
    "modules-center": ["niri/window"],
    "modules-right": ["network", "cpu", "memory", "temperature#TC", "temperature#C1", "temperature#C2", "clock", "tray"],
    "niri/window": {
       "format": "{}",
       "separate-outputs": true,
       "icon": true
    },
    "niri/workspaces": {
      "format": "{icon}",
      "format-icons": {
		// Named workspaces
		// (you need to configure them in niri)
		"browser": "",
		"discord": "",
		"chat": "<b></b>",
		// Icons by state
		"active": "",
		"default": ""
      }
    },

Next is to try to stop wlr/taskbar from shuffling the actual order of the windows.

[YaLTeR]

Next is to try to stop wlr/taskbar from shuffling the actual order of the windows.

I'm afraid you currently can't; need window X/Y in niri IPC and then some custom window module probably.

[chaxor]

This is fantastic and I can't wait until the pull requests go through.

In the meantime I have been working with scripts like those above:

#!/usr/bin/env bash

case "$1" in
focus-workspace)
	niri msg action "$@" && pkill -SIGRTMIN+8 waybar
	;;
*)
	set -e
	monitor=$1
	active_color="#00FFFF"

	# Define the dictionary of workspace names and icons
	declare -A workspace_icons=(["home"]="" ["firefox"]="" ["chromium"]=""
		["dev"]="" ["discord"]="" ["pass"]="" ["signal"]=""
		["notes"]="" ["monitor"]=""
		#["games"]="" #["music"]=""
	)

	# Define dot patterns for window count indicators
	declare -A windowdotsl=(
		[0]=" " [1]="⠈" [2]="⠘" [3]="⠸" [4]="⢸" [5]="⣸"
		[6]="⣹" [7]="⣾" [8]="⣿" [9]="█"
	)
	declare -A windowdotsr=(
		[0]=" " [1]="⠁" [2]="⠃" [3]="⡆" [4]="⡇" [5]="⣇"
		[6]="⣏" [7]="⣷" [8]="⣿" [9]="█"
	)

	# Get workspace information including window counts
	workspace_info=$(niri msg -j workspaces | jq -r ".[] | select(.output == \"$monitor\") | \"\(.name) \(.is_active) \(.windows | length)\"")

	# Initialize an empty output string
	output=""

	# Process each workspace
	while read -r name is_active window_count; do
		icon="${workspace_icons[$name]}"

		# Calculate left and right dot indices
		left_index=$((window_count > 9 ? 9 : window_count))
		right_index=$((window_count > 18 ? 9 : (window_count > 9 ? window_count - 9 : 0)))

		# Construct the workspace indicator
		indicator="${windowdotsl[$left_index]} ${icon}${windowdotsr[$right_index]}"

		if [ "$is_active" = "true" ]; then
			output+="<span color='${active_color}'>"
		fi
		output+="  ${indicator} "
		if [ "$is_active" = "true" ]; then
			output+="</span>"
		fi
	done <<<"$workspace_info"

	# Print the final output
	printf "%s\n" "$output"
	;;
esac

I was wondering if there is any way to get the indicators for the number of windows or columns within each workspace?

Thanks so much for this incredible package.

[YaLTeR]

number of windows within each workspace

You can call niri msg windows and count the number of windows for each workspace_id.

[bphenriques]

Question, do we still need a manual script given that Waybar has niri/workspaces?

https://github.com/Alexays/Waybar/wiki/Module:-Niri

[nebulosa2007]

Yes, in case you want to use on-click-*, on-scroll-* actions and tooltip. This has not been implemented yet.

[cvanelteren]

Here is mine

#!/usr/bin/env nu

let out = {
  text: "",
  alt: "none",
  tooltip: "",
  class: "none"
}

loop {
  sleep 1sec;

  let workspaces = niri msg -j workspaces | from json

  let minimap = $workspaces
    | each { |ws|
        if $ws.is_active {
          # Ocher color for active workspaces
          $"<span foreground='#ffaf00'>[($ws.idx)]</span>"
        } else {
          # Default color for inactive workspaces
          $"($ws.idx)"
        }
      }
    | str join " "

  print (
    $out | update text $minimap
         | to json -r
  )
}