From c504b7f4377fee7ca77b175d83032189daedf306 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 28 Feb 2026 14:00:25 +0000
Subject: [PATCH 01/63] Initial plan


From d5297bc42444f22a7266415d9f3042566c101043 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 28 Feb 2026 14:27:22 +0000
Subject: [PATCH 02/63] fix: resolve PulseAudio/WirePlumber deadlock and freeze
 issues

- Fix AudioBackend destructor: properly lock the PA mainloop before
  disconnecting the context to prevent race conditions with PA callbacks

- Fix context leak on reconnect: call pa_context_unref() when the old
  context is replaced after PA_CONTEXT_FAILED to avoid resource leaks

- Fix PA mainloop killed on reconnect (critical): PA_CONTEXT_TERMINATED
  was unconditionally calling quit() on the mainloop, even during
  reconnection when the old context fires TERMINATED after the new one
  was created. This was killing the new context and preventing successful
  reconnection, causing Waybar to appear frozen. The fix only quits
  the mainloop when the terminating context is still the active one.

- Fix Wireplumber use-after-free: explicitly disconnect GObject signal
  handlers for mixer_api_, def_nodes_api_, and om_ before clearing the
  object references in the destructor to prevent callbacks from firing
  with a destroyed self pointer.

- Fix GVariant memory leak in Wireplumber::handleScroll: unref the
  GVariant created for the set-volume signal after the emit call.

Co-authored-by: Alexays <13947260+Alexays@users.noreply.github.com>
---
 src/modules/wireplumber.cpp | 10 ++++++++++
 src/util/audio_backend.cpp  | 25 +++++++++++++++++++------
 2 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/modules/wireplumber.cpp b/src/modules/wireplumber.cpp
index e9cb7206..0c0d1dde 100644
--- a/src/modules/wireplumber.cpp
+++ b/src/modules/wireplumber.cpp
@@ -54,6 +54,15 @@ waybar::modules::Wireplumber::Wireplumber(const std::string& id, const Json::Val
 
 waybar::modules::Wireplumber::~Wireplumber() {
   waybar::modules::Wireplumber::modules.remove(this);
+  if (mixer_api_ != nullptr) {
+    g_signal_handlers_disconnect_by_data(mixer_api_, this);
+  }
+  if (def_nodes_api_ != nullptr) {
+    g_signal_handlers_disconnect_by_data(def_nodes_api_, this);
+  }
+  if (om_ != nullptr) {
+    g_signal_handlers_disconnect_by_data(om_, this);
+  }
   wp_core_disconnect(wp_core_);
   g_clear_pointer(&apis_, g_ptr_array_unref);
   g_clear_object(&om_);
@@ -528,6 +537,7 @@ bool waybar::modules::Wireplumber::handleScroll(GdkEventScroll* e) {
     GVariant* variant = g_variant_new_double(newVol);
     gboolean ret;
     g_signal_emit_by_name(mixer_api_, "set-volume", node_id_, variant, &ret);
+    g_variant_unref(variant);
   }
   return true;
 }
diff --git a/src/util/audio_backend.cpp b/src/util/audio_backend.cpp
index f61ee945..4087e096 100644
--- a/src/util/audio_backend.cpp
+++ b/src/util/audio_backend.cpp
@@ -40,12 +40,16 @@ AudioBackend::AudioBackend(std::function<void()> on_updated_cb, private_construc
 }
 
 AudioBackend::~AudioBackend() {
-  if (context_ != nullptr) {
-    pa_context_disconnect(context_);
-  }
-
   if (mainloop_ != nullptr) {
-    mainloop_api_->quit(mainloop_api_, 0);
+    // Lock the mainloop so we can safely disconnect the context.
+    // This must be done before stopping the thread.
+    pa_threaded_mainloop_lock(mainloop_);
+    if (context_ != nullptr) {
+      pa_context_disconnect(context_);
+      pa_context_unref(context_);
+      context_ = nullptr;
+    }
+    pa_threaded_mainloop_unlock(mainloop_);
     pa_threaded_mainloop_stop(mainloop_);
     pa_threaded_mainloop_free(mainloop_);
   }
@@ -73,7 +77,14 @@ void AudioBackend::contextStateCb(pa_context* c, void* data) {
   auto* backend = static_cast<AudioBackend*>(data);
   switch (pa_context_get_state(c)) {
     case PA_CONTEXT_TERMINATED:
-      backend->mainloop_api_->quit(backend->mainloop_api_, 0);
+      // Only quit the mainloop if this is still the active context.
+      // During reconnection, the old context fires TERMINATED after the new one
+      // has already been created; quitting in that case would kill the new context.
+      // Note: context_ is only written from PA callbacks (while the mainloop lock is
+      // held), so this comparison is safe within any PA callback.
+      if (backend->context_ == nullptr || backend->context_ == c) {
+        backend->mainloop_api_->quit(backend->mainloop_api_, 0);
+      }
       break;
     case PA_CONTEXT_READY:
       pa_context_get_server_info(c, serverInfoCb, data);
@@ -93,6 +104,8 @@ void AudioBackend::contextStateCb(pa_context* c, void* data) {
       // So there is no need to lock it again.
       if (backend->context_ != nullptr) {
         pa_context_disconnect(backend->context_);
+        pa_context_unref(backend->context_);
+        backend->context_ = nullptr;
       }
       backend->connectContext();
       break;

From dbbad059f7384fdbe88c570014b96f27ab284468 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:39:23 -0600
Subject: [PATCH 03/63] fix(sleeper-thread): stop and join before worker
 reassignment

Reassigning SleeperThread could replace a joinable std::thread and trigger
std::terminate.

I now stop and join any existing worker before reassignment, then reset control
state before starting the replacement worker.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/util/sleeper_thread.hpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/include/util/sleeper_thread.hpp b/include/util/sleeper_thread.hpp
index 62d12931..183083cf 100644
--- a/include/util/sleeper_thread.hpp
+++ b/include/util/sleeper_thread.hpp
@@ -42,6 +42,15 @@ class SleeperThread {
   }
 
   SleeperThread& operator=(std::function<void()> func) {
+    if (thread_.joinable()) {
+      stop();
+      thread_.join();
+    }
+    {
+      std::lock_guard<std::mutex> lck(mutex_);
+      do_run_ = true;
+      signal_ = false;
+    }
     thread_ = std::thread([this, func] {
       while (do_run_) {
         signal_ = false;
@@ -92,7 +101,7 @@ class SleeperThread {
     condvar_.notify_all();
   }
 
-  auto stop() {
+  void stop() {
     {
       std::lock_guard<std::mutex> lck(mutex_);
       signal_ = true;

From 1c61ecf864ae637f4ed649dd8e61e92c1f6e9095 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:39:26 -0600
Subject: [PATCH 04/63] test(utils): add SleeperThread reassignment regression

We needed a regression test for reassignment safety after lifecycle fixes.

I added a subprocess test that reassigns SleeperThread workers and verifies the
process exits normally instead of terminating.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 test/utils/meson.build        |  1 +
 test/utils/sleeper_thread.cpp | 42 +++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 test/utils/sleeper_thread.cpp

diff --git a/test/utils/meson.build b/test/utils/meson.build
index b7b3665a..050af262 100644
--- a/test/utils/meson.build
+++ b/test/utils/meson.build
@@ -13,6 +13,7 @@ test_src = files(
     '../../src/config.cpp',
     'JsonParser.cpp',
     'SafeSignal.cpp',
+    'sleeper_thread.cpp',
     'css_reload_helper.cpp',
     '../../src/util/css_reload_helper.cpp',
 )
diff --git a/test/utils/sleeper_thread.cpp b/test/utils/sleeper_thread.cpp
new file mode 100644
index 00000000..2556a106
--- /dev/null
+++ b/test/utils/sleeper_thread.cpp
@@ -0,0 +1,42 @@
+#if __has_include(<catch2/catch_test_macros.hpp>)
+#include <catch2/catch_test_macros.hpp>
+#else
+#include <catch2/catch.hpp>
+#endif
+
+#include <chrono>
+#include <sys/wait.h>
+#include <thread>
+#include <unistd.h>
+
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::util {
+SafeSignal<bool>& prepare_for_sleep() {
+  static SafeSignal<bool> signal;
+  return signal;
+}
+}  // namespace waybar::util
+
+namespace {
+int run_reassignment_regression() {
+  waybar::util::SleeperThread thread;
+  thread = [] { std::this_thread::sleep_for(std::chrono::milliseconds(10)); };
+  thread = [] { std::this_thread::sleep_for(std::chrono::milliseconds(1)); };
+  return 0;
+}
+}  // namespace
+
+TEST_CASE("SleeperThread reassignment does not terminate process", "[util][sleeper_thread]") {
+  const auto pid = fork();
+  REQUIRE(pid >= 0);
+
+  if (pid == 0) {
+    _exit(run_reassignment_regression());
+  }
+
+  int status = -1;
+  REQUIRE(waitpid(pid, &status, 0) == pid);
+  REQUIRE(WIFEXITED(status));
+  REQUIRE(WEXITSTATUS(status) == 0);
+}

From 44eed7afea7ab251a8aee554a360dbb6fbed6c6d Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:44:26 -0600
Subject: [PATCH 05/63] fix(sleeper-thread): synchronize control flags with
 atomics

SleeperThread control flags were shared across threads without consistent
synchronization.

I converted the run/signal flags to atomics and updated wait predicates and
lifecycle transitions to use explicit atomic loads/stores.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/util/sleeper_thread.hpp | 40 ++++++++++++++++++++-------------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/include/util/sleeper_thread.hpp b/include/util/sleeper_thread.hpp
index 183083cf..966772a2 100644
--- a/include/util/sleeper_thread.hpp
+++ b/include/util/sleeper_thread.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <ctime>
@@ -31,8 +32,8 @@ class SleeperThread {
 
   SleeperThread(std::function<void()> func)
       : thread_{[this, func] {
-          while (do_run_) {
-            signal_ = false;
+          while (do_run_.load(std::memory_order_relaxed)) {
+            signal_.store(false, std::memory_order_relaxed);
             func();
           }
         }} {
@@ -48,12 +49,12 @@ class SleeperThread {
     }
     {
       std::lock_guard<std::mutex> lck(mutex_);
-      do_run_ = true;
-      signal_ = false;
+      do_run_.store(true, std::memory_order_relaxed);
+      signal_.store(false, std::memory_order_relaxed);
     }
     thread_ = std::thread([this, func] {
-      while (do_run_) {
-        signal_ = false;
+      while (do_run_.load(std::memory_order_relaxed)) {
+        signal_.store(false, std::memory_order_relaxed);
         func();
       }
     });
@@ -65,12 +66,15 @@ class SleeperThread {
     return *this;
   }
 
-  bool isRunning() const { return do_run_; }
+  bool isRunning() const { return do_run_.load(std::memory_order_relaxed); }
 
   auto sleep() {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
-    return condvar_.wait(lk, [this] { return signal_ || !do_run_; });
+    return condvar_.wait(lk, [this] {
+      return signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
   }
 
   auto sleep_for(std::chrono::system_clock::duration dur) {
@@ -82,7 +86,10 @@ class SleeperThread {
     if (now < max_time_point - dur) {
       wait_end = now + dur;
     }
-    return condvar_.wait_until(lk, wait_end, [this] { return signal_ || !do_run_; });
+    return condvar_.wait_until(lk, wait_end, [this] {
+      return signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
   }
 
   auto sleep_until(
@@ -90,13 +97,16 @@ class SleeperThread {
           time_point) {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
-    return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
+    return condvar_.wait_until(lk, time_point, [this] {
+      return signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
   }
 
   void wake_up() {
     {
       std::lock_guard<std::mutex> lck(mutex_);
-      signal_ = true;
+      signal_.store(true, std::memory_order_relaxed);
     }
     condvar_.notify_all();
   }
@@ -104,8 +114,8 @@ class SleeperThread {
   void stop() {
     {
       std::lock_guard<std::mutex> lck(mutex_);
-      signal_ = true;
-      do_run_ = false;
+      signal_.store(true, std::memory_order_relaxed);
+      do_run_.store(false, std::memory_order_relaxed);
     }
     condvar_.notify_all();
     auto handle = thread_.native_handle();
@@ -127,8 +137,8 @@ class SleeperThread {
   std::thread thread_;
   std::condition_variable condvar_;
   std::mutex mutex_;
-  bool do_run_ = true;
-  bool signal_ = false;
+  std::atomic<bool> do_run_ = true;
+  std::atomic<bool> signal_ = false;
   sigc::connection connection_;
 };
 

From 864523772d427fea72f99a6fe9dcc100dc708acc Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:44:28 -0600
Subject: [PATCH 06/63] test(utils): stress SleeperThread wake and stop control
 flow

SleeperThread concurrency paths needed stress coverage around wake/stop races.

I added a subprocess stress test that repeatedly interleaves wake_up() and
stop() and verifies the worker exits cleanly.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 test/utils/sleeper_thread.cpp | 59 ++++++++++++++++++++++++++++-------
 1 file changed, 48 insertions(+), 11 deletions(-)

diff --git a/test/utils/sleeper_thread.cpp b/test/utils/sleeper_thread.cpp
index 2556a106..7a9a3ca1 100644
--- a/test/utils/sleeper_thread.cpp
+++ b/test/utils/sleeper_thread.cpp
@@ -19,24 +19,61 @@ SafeSignal<bool>& prepare_for_sleep() {
 }  // namespace waybar::util
 
 namespace {
+int run_in_subprocess(int (*task)()) {
+  const auto pid = fork();
+  if (pid < 0) {
+    return -1;
+  }
+  if (pid == 0) {
+    alarm(5);
+    _exit(task());
+  }
+
+  int status = -1;
+  if (waitpid(pid, &status, 0) != pid) {
+    return -1;
+  }
+  if (!WIFEXITED(status)) {
+    return -1;
+  }
+  return WEXITSTATUS(status);
+}
+
 int run_reassignment_regression() {
   waybar::util::SleeperThread thread;
   thread = [] { std::this_thread::sleep_for(std::chrono::milliseconds(10)); };
   thread = [] { std::this_thread::sleep_for(std::chrono::milliseconds(1)); };
   return 0;
 }
+
+int run_control_flag_stress() {
+  for (int i = 0; i < 200; ++i) {
+    waybar::util::SleeperThread thread;
+    thread = [&thread] { thread.sleep_for(std::chrono::milliseconds(1)); };
+
+    std::thread waker([&thread] {
+      for (int j = 0; j < 100; ++j) {
+        thread.wake_up();
+        std::this_thread::yield();
+      }
+    });
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+    thread.stop();
+    waker.join();
+    if (thread.isRunning()) {
+      return 1;
+    }
+  }
+  return 0;
+}
 }  // namespace
 
 TEST_CASE("SleeperThread reassignment does not terminate process", "[util][sleeper_thread]") {
-  const auto pid = fork();
-  REQUIRE(pid >= 0);
-
-  if (pid == 0) {
-    _exit(run_reassignment_regression());
-  }
-
-  int status = -1;
-  REQUIRE(waitpid(pid, &status, 0) == pid);
-  REQUIRE(WIFEXITED(status));
-  REQUIRE(WEXITSTATUS(status) == 0);
+  REQUIRE(run_in_subprocess(run_reassignment_regression) == 0);
+}
+
+TEST_CASE("SleeperThread control flags are stable under concurrent wake and stop",
+          "[util][sleeper_thread]") {
+  REQUIRE(run_in_subprocess(run_control_flag_stress) == 0);
 }

From e4ff024fa87af9ad63b6a9fc9da8f0beb5afa7c6 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 14:06:27 -0600
Subject: [PATCH 07/63] fix(util): bound SafeSignal queue growth under burst
 load

SafeSignal could queue events forever when worker threads emitted faster than
the main loop could consume, which risks memory growth and stale updates.

I added a queue cap with a drop-oldest policy so growth stays bounded under
burst load, plus a regression test that validates bounded delivery.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/util/SafeSignal.hpp | 20 ++++++++++++++++++++
 test/utils/SafeSignal.cpp   | 31 +++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/include/util/SafeSignal.hpp b/include/util/SafeSignal.hpp
index 340f74ee..1e901792 100644
--- a/include/util/SafeSignal.hpp
+++ b/include/util/SafeSignal.hpp
@@ -6,6 +6,7 @@
 #include <functional>
 #include <mutex>
 #include <queue>
+#include <cstddef>
 #include <thread>
 #include <tuple>
 #include <type_traits>
@@ -27,6 +28,12 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
  public:
   SafeSignal() { dp_.connect(sigc::mem_fun(*this, &SafeSignal::handle_event)); }
 
+  void set_max_queued_events(std::size_t max_queued_events) {
+    std::unique_lock lock(mutex_);
+    max_queued_events_ = max_queued_events;
+    trim_queue_locked();
+  }
+
   template <typename... EmitArgs>
   void emit(EmitArgs&&... args) {
     if (main_tid_ == std::this_thread::get_id()) {
@@ -41,6 +48,9 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
     } else {
       {
         std::unique_lock lock(mutex_);
+        if (max_queued_events_ != 0 && queue_.size() >= max_queued_events_) {
+          queue_.pop();
+        }
         queue_.emplace(std::forward<EmitArgs>(args)...);
       }
       dp_.emit();
@@ -60,6 +70,15 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
   using signal_t::emit_reverse;
   using signal_t::make_slot;
 
+  void trim_queue_locked() {
+    if (max_queued_events_ == 0) {
+      return;
+    }
+    while (queue_.size() > max_queued_events_) {
+      queue_.pop();
+    }
+  }
+
   void handle_event() {
     for (std::unique_lock lock(mutex_); !queue_.empty(); lock.lock()) {
       auto args = queue_.front();
@@ -72,6 +91,7 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
   Glib::Dispatcher dp_;
   std::mutex mutex_;
   std::queue<arg_tuple_t> queue_;
+  std::size_t max_queued_events_ = 4096;
   const std::thread::id main_tid_ = std::this_thread::get_id();
   // cache functor for signal emission to avoid recreating it on each event
   const slot_t cached_fn_ = make_slot();
diff --git a/test/utils/SafeSignal.cpp b/test/utils/SafeSignal.cpp
index e7e096b0..1502b7d9 100644
--- a/test/utils/SafeSignal.cpp
+++ b/test/utils/SafeSignal.cpp
@@ -9,6 +9,7 @@
 #endif
 #include <thread>
 #include <type_traits>
+#include <vector>
 
 #include "fixtures/GlibTestsFixture.hpp"
 
@@ -141,3 +142,33 @@ TEST_CASE_METHOD(GlibTestsFixture, "SafeSignal copy/move counter", "[signal][thr
   producer.join();
   REQUIRE(count == NUM_EVENTS);
 }
+
+TEST_CASE_METHOD(GlibTestsFixture, "SafeSignal queue stays bounded under burst load",
+                 "[signal][thread][util][perf]") {
+  constexpr int NUM_EVENTS = 200;
+  constexpr std::size_t MAX_QUEUED_EVENTS = 8;
+  std::vector<int> received;
+
+  SafeSignal<int> test_signal;
+  test_signal.set_max_queued_events(MAX_QUEUED_EVENTS);
+
+  setTimeout(500);
+
+  test_signal.connect([&](auto value) { received.push_back(value); });
+
+  run([&]() {
+    std::thread producer([&]() {
+      for (int i = 1; i <= NUM_EVENTS; ++i) {
+        test_signal.emit(i);
+      }
+    });
+    producer.join();
+
+    Glib::signal_timeout().connect_once([this]() { this->quit(); }, 50);
+  });
+
+  REQUIRE(received.size() <= MAX_QUEUED_EVENTS);
+  REQUIRE_FALSE(received.empty());
+  REQUIRE(received.back() == NUM_EVENTS);
+  REQUIRE(received.front() == NUM_EVENTS - static_cast<int>(received.size()) + 1);
+}

From d0363313b879c7c7fb1a3cf36a10c943ff2b9c5a Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:48:28 -0600
Subject: [PATCH 08/63] fix(hyprland-ipc): harden fd lifecycle and listener
 loop

Hyprland IPC had fd lifecycle risks on failure/shutdown paths and used a
spin-sleep listener model.

I initialized fd state defensively, tightened connect/close/shutdown handling,
moved to blocking read with newline framing, and added RAII-style fd cleanup in
socket1 reply paths.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/hyprland/backend.hpp |   8 +-
 src/modules/hyprland/backend.cpp     | 139 ++++++++++++++++++---------
 2 files changed, 101 insertions(+), 46 deletions(-)

diff --git a/include/modules/hyprland/backend.hpp b/include/modules/hyprland/backend.hpp
index 2e0ef657..a6ebd191 100644
--- a/include/modules/hyprland/backend.hpp
+++ b/include/modules/hyprland/backend.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <filesystem>
 #include <list>
 #include <mutex>
@@ -43,10 +44,11 @@ class IPC {
 
   std::thread ipcThread_;
   std::mutex callbackMutex_;
+  std::mutex socketMutex_;
   util::JsonParser parser_;
   std::list<std::pair<std::string, EventHandler*>> callbacks_;
-  int socketfd_;  // the hyprland socket file descriptor
-  pid_t socketOwnerPid_;
-  bool running_ = true;  // the ipcThread will stop running when this is false
+  int socketfd_ = -1;  // the hyprland socket file descriptor
+  pid_t socketOwnerPid_ = -1;
+  std::atomic<bool> running_ = true;  // the ipcThread will stop running when this is false
 };
 };  // namespace waybar::modules::hyprland
diff --git a/src/modules/hyprland/backend.cpp b/src/modules/hyprland/backend.cpp
index 7060d304..4022d408 100644
--- a/src/modules/hyprland/backend.cpp
+++ b/src/modules/hyprland/backend.cpp
@@ -9,11 +9,35 @@
 #include <sys/un.h>
 #include <unistd.h>
 
+#include <array>
+#include <cerrno>
+#include <cstring>
 #include <filesystem>
 #include <string>
 
 namespace waybar::modules::hyprland {
 
+namespace {
+class ScopedFd {
+ public:
+  explicit ScopedFd(int fd) : fd_(fd) {}
+  ~ScopedFd() {
+    if (fd_ != -1) {
+      close(fd_);
+    }
+  }
+
+  // ScopedFd is non-copyable
+  ScopedFd(const ScopedFd&) = delete;
+  ScopedFd& operator=(const ScopedFd&) = delete;
+
+  int get() const { return fd_; }
+
+ private:
+  int fd_;
+};
+}  // namespace
+
 std::filesystem::path IPC::socketFolder_;
 
 std::filesystem::path IPC::getSocketFolder(const char* instanceSig) {
@@ -45,8 +69,8 @@ std::filesystem::path IPC::getSocketFolder(const char* instanceSig) {
 
 IPC::IPC() {
   // will start IPC and relay events to parseIPC
-  ipcThread_ = std::thread([this]() { socketListener(); });
   socketOwnerPid_ = getpid();
+  ipcThread_ = std::thread([this]() { socketListener(); });
 }
 
 IPC::~IPC() {
@@ -54,19 +78,20 @@ IPC::~IPC() {
   // failed exec()) exits.
   if (getpid() != socketOwnerPid_) return;
 
-  running_ = false;
+  running_.store(false, std::memory_order_relaxed);
   spdlog::info("Hyprland IPC stopping...");
-  if (socketfd_ != -1) {
-    spdlog::trace("Shutting down socket");
-    if (shutdown(socketfd_, SHUT_RDWR) == -1) {
-      spdlog::error("Hyprland IPC: Couldn't shutdown socket");
-    }
-    spdlog::trace("Closing socket");
-    if (close(socketfd_) == -1) {
-      spdlog::error("Hyprland IPC: Couldn't close socket");
+  {
+    std::lock_guard<std::mutex> lock(socketMutex_);
+    if (socketfd_ != -1) {
+      spdlog::trace("Shutting down socket");
+      if (shutdown(socketfd_, SHUT_RDWR) == -1 && errno != ENOTCONN) {
+        spdlog::error("Hyprland IPC: Couldn't shutdown socket");
+      }
     }
   }
-  ipcThread_.join();
+  if (ipcThread_.joinable()) {
+    ipcThread_.join();
+  }
 }
 
 IPC& IPC::inst() {
@@ -86,9 +111,9 @@ void IPC::socketListener() {
   spdlog::info("Hyprland IPC starting");
 
   struct sockaddr_un addr;
-  socketfd_ = socket(AF_UNIX, SOCK_STREAM, 0);
+  const int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
 
-  if (socketfd_ == -1) {
+  if (socketfd == -1) {
     spdlog::error("Hyprland IPC: socketfd failed");
     return;
   }
@@ -102,38 +127,67 @@ void IPC::socketListener() {
 
   int l = sizeof(struct sockaddr_un);
 
-  if (connect(socketfd_, (struct sockaddr*)&addr, l) == -1) {
-    spdlog::error("Hyprland IPC: Unable to connect?");
+  if (connect(socketfd, (struct sockaddr*)&addr, l) == -1) {
+    spdlog::error("Hyprland IPC: Unable to connect? {}", std::strerror(errno));
+    close(socketfd);
     return;
   }
-  auto* file = fdopen(socketfd_, "r");
-  if (file == nullptr) {
-    spdlog::error("Hyprland IPC: Couldn't open file descriptor");
-    return;
+
+  {
+    std::lock_guard<std::mutex> lock(socketMutex_);
+    socketfd_ = socketfd;
   }
-  while (running_) {
+
+  std::string pending;
+  while (running_.load(std::memory_order_relaxed)) {
     std::array<char, 1024> buffer;  // Hyprland socket2 events are max 1024 bytes
+    const ssize_t bytes_read = read(socketfd, buffer.data(), buffer.size());
 
-    auto* receivedCharPtr = fgets(buffer.data(), buffer.size(), file);
-
-    if (receivedCharPtr == nullptr) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      continue;
+    if (bytes_read == 0) {
+      if (running_.load(std::memory_order_relaxed)) {
+        spdlog::warn("Hyprland IPC: Socket closed by peer");
+      }
+      break;
     }
 
-    std::string messageReceived(buffer.data());
-    messageReceived = messageReceived.substr(0, messageReceived.find_first_of('\n'));
-    spdlog::debug("hyprland IPC received {}", messageReceived);
-
-    try {
-      parseIPC(messageReceived);
-    } catch (std::exception& e) {
-      spdlog::warn("Failed to parse IPC message: {}, reason: {}", messageReceived, e.what());
-    } catch (...) {
-      throw;
+    if (bytes_read < 0) {
+      if (errno == EINTR) {
+        continue;
+      }
+      if (!running_.load(std::memory_order_relaxed)) {
+        break;
+      }
+      spdlog::error("Hyprland IPC: read failed: {}", std::strerror(errno));
+      break;
     }
 
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    pending.append(buffer.data(), static_cast<std::size_t>(bytes_read));
+    for (auto newline_pos = pending.find('\n'); newline_pos != std::string::npos;
+         newline_pos = pending.find('\n')) {
+      std::string messageReceived = pending.substr(0, newline_pos);
+      pending.erase(0, newline_pos + 1);
+      if (messageReceived.empty()) {
+        continue;
+      }
+      spdlog::debug("hyprland IPC received {}", messageReceived);
+
+      try {
+        parseIPC(messageReceived);
+      } catch (std::exception& e) {
+        spdlog::warn("Failed to parse IPC message: {}, reason: {}", messageReceived, e.what());
+      } catch (...) {
+        throw;
+      }
+    }
+  }
+  {
+    std::lock_guard<std::mutex> lock(socketMutex_);
+    if (socketfd_ != -1) {
+      if (close(socketfd_) == -1) {
+        spdlog::error("Hyprland IPC: Couldn't close socket");
+      }
+      socketfd_ = -1;
+    }
   }
   spdlog::debug("Hyprland IPC stopped");
 }
@@ -178,9 +232,9 @@ void IPC::unregisterForIPC(EventHandler* ev_handler) {
 std::string IPC::getSocket1Reply(const std::string& rq) {
   // basically hyprctl
 
-  const auto serverSocket = socket(AF_UNIX, SOCK_STREAM, 0);
+  ScopedFd serverSocket(socket(AF_UNIX, SOCK_STREAM, 0));
 
-  if (serverSocket < 0) {
+  if (serverSocket.get() < 0) {
     throw std::runtime_error("Hyprland IPC: Couldn't open a socket (1)");
   }
 
@@ -203,12 +257,13 @@ std::string IPC::getSocket1Reply(const std::string& rq) {
     throw std::runtime_error("Hyprland IPC: Couldn't copy socket path (6)");
   }
 
-  if (connect(serverSocket, reinterpret_cast<sockaddr*>(&serverAddress), sizeof(serverAddress)) <
+  if (connect(serverSocket.get(), reinterpret_cast<sockaddr*>(&serverAddress),
+              sizeof(serverAddress)) <
       0) {
     throw std::runtime_error("Hyprland IPC: Couldn't connect to " + socketPath + ". (3)");
   }
 
-  auto sizeWritten = write(serverSocket, rq.c_str(), rq.length());
+  auto sizeWritten = write(serverSocket.get(), rq.c_str(), rq.length());
 
   if (sizeWritten < 0) {
     spdlog::error("Hyprland IPC: Couldn't write (4)");
@@ -219,17 +274,15 @@ std::string IPC::getSocket1Reply(const std::string& rq) {
   std::string response;
 
   do {
-    sizeWritten = read(serverSocket, buffer.data(), 8192);
+    sizeWritten = read(serverSocket.get(), buffer.data(), 8192);
 
     if (sizeWritten < 0) {
       spdlog::error("Hyprland IPC: Couldn't read (5)");
-      close(serverSocket);
       return "";
     }
     response.append(buffer.data(), sizeWritten);
   } while (sizeWritten > 0);
 
-  close(serverSocket);
   return response;
 }
 

From 87a5b7ed0fd683bc565e89ece3f36412dbd0f648 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:48:30 -0600
Subject: [PATCH 09/63] test(hyprland): add failure-path fd-leak coverage

Hyprland tests did not explicitly verify descriptor behavior on key failure
paths.

I added focused tests for missing instance signature and connect-failure paths
that assert file descriptor counts stay stable across repeated attempts.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 test/hyprland/backend.cpp | 80 +++++++++++++++++++++++++++++++++------
 1 file changed, 69 insertions(+), 11 deletions(-)

diff --git a/test/hyprland/backend.cpp b/test/hyprland/backend.cpp
index b83b839c..cc7295ec 100644
--- a/test/hyprland/backend.cpp
+++ b/test/hyprland/backend.cpp
@@ -4,56 +4,114 @@
 #include <catch2/catch.hpp>
 #endif
 
-#include "fixtures/IPCTestFixture.hpp"
+#include <system_error>
+
+#include "modules/hyprland/backend.hpp"
 
 namespace fs = std::filesystem;
 namespace hyprland = waybar::modules::hyprland;
 
-TEST_CASE_METHOD(IPCTestFixture, "XDGRuntimeDirExists", "[getSocketFolder]") {
+namespace {
+class IPCTestHelper : public hyprland::IPC {
+ public:
+  static void resetSocketFolder() { socketFolder_.clear(); }
+};
+
+std::size_t countOpenFds() {
+#if defined(__linux__)
+  std::size_t count = 0;
+  for (const auto& _ : fs::directory_iterator("/proc/self/fd")) {
+    (void)_;
+    ++count;
+  }
+  return count;
+#else
+  return 0;
+#endif
+}
+}  // namespace
+
+TEST_CASE("XDGRuntimeDirExists", "[getSocketFolder]") {
   // Test case: XDG_RUNTIME_DIR exists and contains "hypr" directory
   // Arrange
-  tempDir = fs::temp_directory_path() / "hypr_test/run/user/1000";
+  constexpr auto instanceSig = "instance_sig";
+  const fs::path tempDir = fs::temp_directory_path() / "hypr_test/run/user/1000";
+  std::error_code ec;
+  fs::remove_all(tempDir, ec);
   fs::path expectedPath = tempDir / "hypr" / instanceSig;
-  fs::create_directories(tempDir / "hypr" / instanceSig);
+  fs::create_directories(expectedPath);
   setenv("XDG_RUNTIME_DIR", tempDir.c_str(), 1);
+  IPCTestHelper::resetSocketFolder();
 
   // Act
-  fs::path actualPath = getSocketFolder(instanceSig);
+  fs::path actualPath = hyprland::IPC::getSocketFolder(instanceSig);
 
   // Assert expected result
   REQUIRE(actualPath == expectedPath);
+  fs::remove_all(tempDir, ec);
 }
 
-TEST_CASE_METHOD(IPCTestFixture, "XDGRuntimeDirDoesNotExist", "[getSocketFolder]") {
+TEST_CASE("XDGRuntimeDirDoesNotExist", "[getSocketFolder]") {
   // Test case: XDG_RUNTIME_DIR does not exist
   // Arrange
+  constexpr auto instanceSig = "instance_sig";
   unsetenv("XDG_RUNTIME_DIR");
   fs::path expectedPath = fs::path("/tmp") / "hypr" / instanceSig;
+  IPCTestHelper::resetSocketFolder();
 
   // Act
-  fs::path actualPath = getSocketFolder(instanceSig);
+  fs::path actualPath = hyprland::IPC::getSocketFolder(instanceSig);
 
   // Assert expected result
   REQUIRE(actualPath == expectedPath);
 }
 
-TEST_CASE_METHOD(IPCTestFixture, "XDGRuntimeDirExistsNoHyprDir", "[getSocketFolder]") {
+TEST_CASE("XDGRuntimeDirExistsNoHyprDir", "[getSocketFolder]") {
   // Test case: XDG_RUNTIME_DIR exists but does not contain "hypr" directory
   // Arrange
+  constexpr auto instanceSig = "instance_sig";
   fs::path tempDir = fs::temp_directory_path() / "hypr_test/run/user/1000";
+  std::error_code ec;
+  fs::remove_all(tempDir, ec);
   fs::create_directories(tempDir);
   setenv("XDG_RUNTIME_DIR", tempDir.c_str(), 1);
   fs::path expectedPath = fs::path("/tmp") / "hypr" / instanceSig;
+  IPCTestHelper::resetSocketFolder();
 
   // Act
-  fs::path actualPath = getSocketFolder(instanceSig);
+  fs::path actualPath = hyprland::IPC::getSocketFolder(instanceSig);
 
   // Assert expected result
   REQUIRE(actualPath == expectedPath);
+  fs::remove_all(tempDir, ec);
 }
 
-TEST_CASE_METHOD(IPCTestFixture, "getSocket1Reply throws on no socket", "[getSocket1Reply]") {
+TEST_CASE("getSocket1Reply throws on no socket", "[getSocket1Reply]") {
+  unsetenv("HYPRLAND_INSTANCE_SIGNATURE");
+  IPCTestHelper::resetSocketFolder();
   std::string request = "test_request";
 
-  CHECK_THROWS(getSocket1Reply(request));
+  CHECK_THROWS(hyprland::IPC::getSocket1Reply(request));
 }
+
+#if defined(__linux__)
+TEST_CASE("getSocket1Reply failure paths do not leak fds", "[getSocket1Reply][fd-leak]") {
+  const auto baseline = countOpenFds();
+
+  unsetenv("HYPRLAND_INSTANCE_SIGNATURE");
+  for (int i = 0; i < 16; ++i) {
+    IPCTestHelper::resetSocketFolder();
+    CHECK_THROWS(hyprland::IPC::getSocket1Reply("test_request"));
+  }
+  const auto after_missing_signature = countOpenFds();
+  REQUIRE(after_missing_signature == baseline);
+
+  setenv("HYPRLAND_INSTANCE_SIGNATURE", "definitely-not-running", 1);
+  for (int i = 0; i < 16; ++i) {
+    IPCTestHelper::resetSocketFolder();
+    CHECK_THROWS(hyprland::IPC::getSocket1Reply("test_request"));
+  }
+  const auto after_connect_failures = countOpenFds();
+  REQUIRE(after_connect_failures == baseline);
+}
+#endif

From 04ddc5fd23cfad281f725eda3160f9c5ef4a0ee5 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 14:01:45 -0600
Subject: [PATCH 10/63] chore(test-hyprland): remove unused IPC test fixture

The hyprland IPC fixture was no longer used by the current test setup.

I removed the dead fixture so the test code reflects the actual execution path
and is easier to maintain.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 test/hyprland/fixtures/IPCTestFixture.hpp | 25 -----------------------
 1 file changed, 25 deletions(-)
 delete mode 100644 test/hyprland/fixtures/IPCTestFixture.hpp

diff --git a/test/hyprland/fixtures/IPCTestFixture.hpp b/test/hyprland/fixtures/IPCTestFixture.hpp
deleted file mode 100644
index caa92975..00000000
--- a/test/hyprland/fixtures/IPCTestFixture.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "modules/hyprland/backend.hpp"
-
-namespace fs = std::filesystem;
-namespace hyprland = waybar::modules::hyprland;
-
-class IPCTestFixture : public hyprland::IPC {
- public:
-  IPCTestFixture() : IPC() { IPC::socketFolder_ = ""; }
-  ~IPCTestFixture() { fs::remove_all(tempDir); }
-
- protected:
-  const char* instanceSig = "instance_sig";
-  fs::path tempDir = fs::temp_directory_path() / "hypr_test";
-
- private:
-};
-
-class IPCMock : public IPCTestFixture {
- public:
-  // Mock getSocket1Reply to return an empty string
-  static std::string getSocket1Reply(const std::string& rq) { return ""; }
-
- protected:
-  const char* instanceSig = "instance_sig";
-};

From 6dfe1c31111602fe2f92ca81e0907ec1f5903639 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 08:21:12 -0600
Subject: [PATCH 11/63] feat(util): add ScopedFd RAII utility for file
 descriptors

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/util/scoped_fd.hpp | 54 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 include/util/scoped_fd.hpp

diff --git a/include/util/scoped_fd.hpp b/include/util/scoped_fd.hpp
new file mode 100644
index 00000000..e970109e
--- /dev/null
+++ b/include/util/scoped_fd.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <unistd.h>
+
+namespace waybar::util {
+
+class ScopedFd {
+ public:
+  explicit ScopedFd(int fd = -1) : fd_(fd) {}
+  ~ScopedFd() {
+    if (fd_ != -1) {
+      close(fd_);
+    }
+  }
+
+  // ScopedFd is non-copyable
+  ScopedFd(const ScopedFd&) = delete;
+  ScopedFd& operator=(const ScopedFd&) = delete;
+
+  // ScopedFd is moveable
+  ScopedFd(ScopedFd&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+  ScopedFd& operator=(ScopedFd&& other) noexcept {
+    if (this != &other) {
+      if (fd_ != -1) {
+        close(fd_);
+      }
+      fd_ = other.fd_;
+      other.fd_ = -1;
+    }
+    return *this;
+  }
+
+  int get() const { return fd_; }
+
+  operator int() const { return fd_; }
+
+  void reset(int fd = -1) {
+    if (fd_ != -1) {
+      close(fd_);
+    }
+    fd_ = fd;
+  }
+
+  int release() {
+    int fd = fd_;
+    fd_ = -1;
+    return fd;
+  }
+
+ private:
+  int fd_;
+};
+
+}  // namespace waybar::util

From e83ab7609c7e6f5eb3eb038c905ba37ea1ed22b8 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 08:21:15 -0600
Subject: [PATCH 12/63] refactor(hyprland): use shared ScopedFd utility

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/hyprland/backend.cpp | 34 +++++++-------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)

diff --git a/src/modules/hyprland/backend.cpp b/src/modules/hyprland/backend.cpp
index 4022d408..0f02b919 100644
--- a/src/modules/hyprland/backend.cpp
+++ b/src/modules/hyprland/backend.cpp
@@ -15,29 +15,10 @@
 #include <filesystem>
 #include <string>
 
+#include "util/scoped_fd.hpp"
+
 namespace waybar::modules::hyprland {
 
-namespace {
-class ScopedFd {
- public:
-  explicit ScopedFd(int fd) : fd_(fd) {}
-  ~ScopedFd() {
-    if (fd_ != -1) {
-      close(fd_);
-    }
-  }
-
-  // ScopedFd is non-copyable
-  ScopedFd(const ScopedFd&) = delete;
-  ScopedFd& operator=(const ScopedFd&) = delete;
-
-  int get() const { return fd_; }
-
- private:
-  int fd_;
-};
-}  // namespace
-
 std::filesystem::path IPC::socketFolder_;
 
 std::filesystem::path IPC::getSocketFolder(const char* instanceSig) {
@@ -232,9 +213,9 @@ void IPC::unregisterForIPC(EventHandler* ev_handler) {
 std::string IPC::getSocket1Reply(const std::string& rq) {
   // basically hyprctl
 
-  ScopedFd serverSocket(socket(AF_UNIX, SOCK_STREAM, 0));
+  util::ScopedFd serverSocket(socket(AF_UNIX, SOCK_STREAM, 0));
 
-  if (serverSocket.get() < 0) {
+  if (serverSocket < 0) {
     throw std::runtime_error("Hyprland IPC: Couldn't open a socket (1)");
   }
 
@@ -257,13 +238,12 @@ std::string IPC::getSocket1Reply(const std::string& rq) {
     throw std::runtime_error("Hyprland IPC: Couldn't copy socket path (6)");
   }
 
-  if (connect(serverSocket.get(), reinterpret_cast<sockaddr*>(&serverAddress),
-              sizeof(serverAddress)) <
+  if (connect(serverSocket, reinterpret_cast<sockaddr*>(&serverAddress), sizeof(serverAddress)) <
       0) {
     throw std::runtime_error("Hyprland IPC: Couldn't connect to " + socketPath + ". (3)");
   }
 
-  auto sizeWritten = write(serverSocket.get(), rq.c_str(), rq.length());
+  auto sizeWritten = write(serverSocket, rq.c_str(), rq.length());
 
   if (sizeWritten < 0) {
     spdlog::error("Hyprland IPC: Couldn't write (4)");
@@ -274,7 +254,7 @@ std::string IPC::getSocket1Reply(const std::string& rq) {
   std::string response;
 
   do {
-    sizeWritten = read(serverSocket.get(), buffer.data(), 8192);
+    sizeWritten = read(serverSocket, buffer.data(), 8192);
 
     if (sizeWritten < 0) {
       spdlog::error("Hyprland IPC: Couldn't read (5)");

From 2ff77fb73dd2e14d399c22fa77242aea1fbf8a8f Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 08:21:17 -0600
Subject: [PATCH 13/63] refactor(niri): use shared ScopedFd utility

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/niri/backend.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/modules/niri/backend.cpp b/src/modules/niri/backend.cpp
index 68bb1724..c23aaa47 100644
--- a/src/modules/niri/backend.cpp
+++ b/src/modules/niri/backend.cpp
@@ -13,6 +13,7 @@
 #include <string>
 #include <thread>
 
+#include "util/scoped_fd.hpp"
 #include "giomm/datainputstream.h"
 #include "giomm/dataoutputstream.h"
 #include "giomm/unixinputstream.h"
@@ -30,7 +31,7 @@ int IPC::connectToSocket() {
   }
 
   struct sockaddr_un addr;
-  int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
+  util::ScopedFd socketfd(socket(AF_UNIX, SOCK_STREAM, 0));
 
   if (socketfd == -1) {
     throw std::runtime_error("socketfd failed");
@@ -45,11 +46,10 @@ int IPC::connectToSocket() {
   int l = sizeof(struct sockaddr_un);
 
   if (connect(socketfd, (struct sockaddr*)&addr, l) == -1) {
-    close(socketfd);
     throw std::runtime_error("unable to connect");
   }
 
-  return socketfd;
+  return socketfd.release();
 }
 
 void IPC::startIPC() {
@@ -235,7 +235,7 @@ void IPC::unregisterForIPC(EventHandler* ev_handler) {
 }
 
 Json::Value IPC::send(const Json::Value& request) {
-  int socketfd = connectToSocket();
+  util::ScopedFd socketfd(connectToSocket());
 
   auto unix_istream = Gio::UnixInputStream::create(socketfd, true);
   auto unix_ostream = Gio::UnixOutputStream::create(socketfd, false);

From 39e09118f9943c62000542cd35af735b5f9826a1 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 08:21:20 -0600
Subject: [PATCH 14/63] refactor(wayfire): replace custom Sock with shared
 ScopedFd

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/wayfire/backend.hpp | 20 +++-----------------
 src/modules/wayfire/backend.cpp     | 11 +++++------
 2 files changed, 8 insertions(+), 23 deletions(-)

diff --git a/include/modules/wayfire/backend.hpp b/include/modules/wayfire/backend.hpp
index d3173269..e1f259cc 100644
--- a/include/modules/wayfire/backend.hpp
+++ b/include/modules/wayfire/backend.hpp
@@ -12,6 +12,8 @@
 #include <unordered_map>
 #include <utility>
 
+#include "util/scoped_fd.hpp"
+
 namespace waybar::modules::wayfire {
 
 using EventHandler = std::function<void(const std::string& event)>;
@@ -71,23 +73,7 @@ struct State {
   auto update_view(const Json::Value& view) -> void;
 };
 
-struct Sock {
-  int fd;
-
-  Sock(int fd) : fd{fd} {}
-  ~Sock() { close(fd); }
-  Sock(const Sock&) = delete;
-  auto operator=(const Sock&) = delete;
-  Sock(Sock&& rhs) noexcept {
-    fd = rhs.fd;
-    rhs.fd = -1;
-  }
-  auto& operator=(Sock&& rhs) noexcept {
-    fd = rhs.fd;
-    rhs.fd = -1;
-    return *this;
-  }
-};
+using Sock = util::ScopedFd;
 
 class IPC : public std::enable_shared_from_this<IPC> {
   static std::weak_ptr<IPC> instance;
diff --git a/src/modules/wayfire/backend.cpp b/src/modules/wayfire/backend.cpp
index 545aaa89..42976d20 100644
--- a/src/modules/wayfire/backend.cpp
+++ b/src/modules/wayfire/backend.cpp
@@ -27,14 +27,14 @@ inline auto byteswap(uint32_t x) -> uint32_t {
 auto pack_and_write(Sock& sock, std::string&& buf) -> void {
   uint32_t len = buf.size();
   if constexpr (std::endian::native != std::endian::little) len = byteswap(len);
-  (void)write(sock.fd, &len, 4);
-  (void)write(sock.fd, buf.data(), buf.size());
+  (void)write(sock, &len, 4);
+  (void)write(sock, buf.data(), buf.size());
 }
 
 auto read_exact(Sock& sock, size_t n) -> std::string {
   auto buf = std::string(n, 0);
   for (size_t i = 0; i < n;) {
-    auto r = read(sock.fd, &buf[i], n - i);
+    auto r = read(sock, &buf[i], n - i);
     if (r <= 0) {
       throw std::runtime_error("Wayfire IPC: read failed");
     }
@@ -111,7 +111,7 @@ auto IPC::connect() -> Sock {
     throw std::runtime_error{"Wayfire IPC: ipc not available"};
   }
 
-  auto sock = socket(AF_UNIX, SOCK_STREAM, 0);
+  util::ScopedFd sock(socket(AF_UNIX, SOCK_STREAM, 0));
   if (sock == -1) {
     throw std::runtime_error{"Wayfire IPC: socket() failed"};
   }
@@ -121,11 +121,10 @@ auto IPC::connect() -> Sock {
   addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
 
   if (::connect(sock, (const sockaddr*)&addr, sizeof(addr)) == -1) {
-    close(sock);
     throw std::runtime_error{"Wayfire IPC: connect() failed"};
   }
 
-  return {sock};
+  return sock;
 }
 
 auto IPC::receive(Sock& sock) -> Json::Value {

From 8d22d3e07a629470114edcebabe6d6fb6afe85cf Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 08:23:06 -0600
Subject: [PATCH 15/63] refactor(sway): use shared ScopedFd for IPC sockets

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/sway/ipc/client.hpp |  5 +++--
 src/modules/sway/ipc/client.cpp     | 12 ++++--------
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/include/modules/sway/ipc/client.hpp b/include/modules/sway/ipc/client.hpp
index 281df7ab..eb0f32f9 100644
--- a/include/modules/sway/ipc/client.hpp
+++ b/include/modules/sway/ipc/client.hpp
@@ -14,6 +14,7 @@
 #include "ipc.hpp"
 #include "util/SafeSignal.hpp"
 #include "util/sleeper_thread.hpp"
+#include "util/scoped_fd.hpp"
 
 namespace waybar::modules::sway {
 
@@ -45,8 +46,8 @@ class Ipc {
   struct ipc_response send(int fd, uint32_t type, const std::string& payload = "");
   struct ipc_response recv(int fd);
 
-  int fd_;
-  int fd_event_;
+  util::ScopedFd fd_;
+  util::ScopedFd fd_event_;
   std::mutex mutex_;
   util::SleeperThread thread_;
 };
diff --git a/src/modules/sway/ipc/client.cpp b/src/modules/sway/ipc/client.cpp
index 4139a53b..3ebccccd 100644
--- a/src/modules/sway/ipc/client.cpp
+++ b/src/modules/sway/ipc/client.cpp
@@ -9,8 +9,8 @@ namespace waybar::modules::sway {
 
 Ipc::Ipc() {
   const std::string& socketPath = getSocketPath();
-  fd_ = open(socketPath);
-  fd_event_ = open(socketPath);
+  fd_ = util::ScopedFd(open(socketPath));
+  fd_event_ = util::ScopedFd(open(socketPath));
 }
 
 Ipc::~Ipc() {
@@ -21,15 +21,11 @@ Ipc::~Ipc() {
     if (write(fd_, "close-sway-ipc", 14) == -1) {
       spdlog::error("Failed to close sway IPC");
     }
-    close(fd_);
-    fd_ = -1;
   }
   if (fd_event_ > 0) {
     if (write(fd_event_, "close-sway-ipc", 14) == -1) {
       spdlog::error("Failed to close sway IPC event handler");
     }
-    close(fd_event_);
-    fd_event_ = -1;
   }
 }
 
@@ -64,7 +60,7 @@ const std::string Ipc::getSocketPath() const {
 }
 
 int Ipc::open(const std::string& socketPath) const {
-  int32_t fd = socket(AF_UNIX, SOCK_STREAM, 0);
+  util::ScopedFd fd(socket(AF_UNIX, SOCK_STREAM, 0));
   if (fd == -1) {
     throw std::runtime_error("Unable to open Unix socket");
   }
@@ -78,7 +74,7 @@ int Ipc::open(const std::string& socketPath) const {
   if (::connect(fd, reinterpret_cast<struct sockaddr*>(&addr), l) == -1) {
     throw std::runtime_error("Unable to connect to Sway");
   }
-  return fd;
+  return fd.release();
 }
 
 struct Ipc::ipc_response Ipc::recv(int fd) {

From 5e7dbf171542a3e1a0457488a23c7562cbec0fd1 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:12:42 -0600
Subject: [PATCH 16/63] fix(command): return non-zero when child exec fails

Child exec failure paths were returning success, which masked command launch
errors from callers.

I switched the child-side failure exits to _exit(127) and added errno-specific
logging so failures propagate with actionable diagnostics.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/util/command.hpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/include/util/command.hpp b/include/util/command.hpp
index b1adcd7c..f6d2cabf 100644
--- a/include/util/command.hpp
+++ b/include/util/command.hpp
@@ -20,6 +20,8 @@ extern std::list<pid_t> reap;
 
 namespace waybar::util::command {
 
+constexpr int kExecFailureExitCode = 127;
+
 struct res {
   int exit_code;
   std::string out;
@@ -114,7 +116,9 @@ inline FILE* open(const std::string& cmd, int& pid, const std::string& output_na
       setenv("WAYBAR_OUTPUT_NAME", output_name.c_str(), 1);
     }
     execlp("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
-    exit(0);
+    const int saved_errno = errno;
+    spdlog::error("execlp(/bin/sh) failed in open: {}", strerror(saved_errno));
+    _exit(kExecFailureExitCode);
   } else {
     ::close(fd[1]);
   }
@@ -162,7 +166,9 @@ inline int32_t forkExec(const std::string& cmd, const std::string& output_name)
       setenv("WAYBAR_OUTPUT_NAME", output_name.c_str(), 1);
     }
     execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
-    exit(0);
+    const int saved_errno = errno;
+    spdlog::error("execl(/bin/sh) failed in forkExec: {}", strerror(saved_errno));
+    _exit(kExecFailureExitCode);
   } else {
     reap_mtx.lock();
     reap.push_back(pid);

From 79fb1d9f58d15cb3704a62359a7457451cbc0164 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 9 Feb 2026 13:12:45 -0600
Subject: [PATCH 17/63] test(command): cover exec failure paths

Command tests did not assert behavior when exec fails in child processes.

I added deterministic regression coverage that forces execl/execlp failure and
verifies non-zero exit status propagation for both open() and forkExec paths.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 test/utils/command.cpp | 56 ++++++++++++++++++++++++++++++++++++++++++
 test/utils/meson.build |  1 +
 2 files changed, 57 insertions(+)
 create mode 100644 test/utils/command.cpp

diff --git a/test/utils/command.cpp b/test/utils/command.cpp
new file mode 100644
index 00000000..2ccb3383
--- /dev/null
+++ b/test/utils/command.cpp
@@ -0,0 +1,56 @@
+#if __has_include(<catch2/catch_test_macros.hpp>)
+#include <catch2/catch_test_macros.hpp>
+#else
+#include <catch2/catch.hpp>
+#endif
+
+#include <cerrno>
+#include <list>
+#include <mutex>
+#include <sys/wait.h>
+#include <unistd.h>
+
+std::mutex reap_mtx;
+std::list<pid_t> reap;
+
+extern "C" int waybar_test_execl(const char* path, const char* arg, ...);
+extern "C" int waybar_test_execlp(const char* file, const char* arg, ...);
+
+#define execl waybar_test_execl
+#define execlp waybar_test_execlp
+#include "util/command.hpp"
+#undef execl
+#undef execlp
+
+extern "C" int waybar_test_execl(const char* path, const char* arg, ...) {
+  (void)path;
+  (void)arg;
+  errno = ENOENT;
+  return -1;
+}
+
+extern "C" int waybar_test_execlp(const char* file, const char* arg, ...) {
+  (void)file;
+  (void)arg;
+  errno = ENOENT;
+  return -1;
+}
+
+TEST_CASE("command::execNoRead returns 127 when shell exec fails", "[util][command]") {
+  const auto result = waybar::util::command::execNoRead("echo should-not-run");
+  REQUIRE(result.exit_code == waybar::util::command::kExecFailureExitCode);
+  REQUIRE(result.out.empty());
+}
+
+TEST_CASE("command::forkExec child exits 127 when shell exec fails", "[util][command]") {
+  const auto pid = waybar::util::command::forkExec("echo should-not-run", "test-output");
+  REQUIRE(pid > 0);
+
+  int status = -1;
+  REQUIRE(waitpid(pid, &status, 0) == pid);
+  REQUIRE(WIFEXITED(status));
+  REQUIRE(WEXITSTATUS(status) == waybar::util::command::kExecFailureExitCode);
+
+  std::scoped_lock<std::mutex> lock(reap_mtx);
+  reap.remove(pid);
+}
diff --git a/test/utils/meson.build b/test/utils/meson.build
index 050af262..e8dd37fa 100644
--- a/test/utils/meson.build
+++ b/test/utils/meson.build
@@ -14,6 +14,7 @@ test_src = files(
     'JsonParser.cpp',
     'SafeSignal.cpp',
     'sleeper_thread.cpp',
+    'command.cpp',
     'css_reload_helper.cpp',
     '../../src/util/css_reload_helper.cpp',
 )

From d929f1a62c764a4cff0897540bc00bf24beb0d5e Mon Sep 17 00:00:00 2001
From: Bryce Gust <bryce.gust@MacBook-Pro.eau.wi.charter.com>
Date: Mon, 2 Mar 2026 17:58:00 -0600
Subject: [PATCH 18/63] Fix 4894 - float interval cast

---
 src/ALabel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ALabel.cpp b/src/ALabel.cpp
index 0d92c372..fe87e098 100644
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@@ -26,7 +26,7 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
                     : std::chrono::milliseconds(
                           (config_["interval"].isNumeric()
                                ? std::max(1L,  // Minimum 1ms due to millisecond precision
-                                          static_cast<long>(config_["interval"].asDouble()) * 1000)
+                                          static_cast<long>(config_["interval"].asDouble() * 1000))
                                : 1000 * (long)interval))),
       default_format_(format_) {
   label_.set_name(name);

From 25089b24567c853ad79d09175f2de9dcfe4127f9 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 21:22:53 -0600
Subject: [PATCH 19/63] fix(network): align tooltip and tooltip text

Closes https://github.com/Alexays/Waybar/issues/4867

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/network.cpp | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index 34dcc03c..e0866011 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -373,18 +373,26 @@ auto waybar::modules::Network::update() -> void {
           fmt::arg("cidr6", cidr6_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
           fmt::arg("icon", getIcon(signal_strength_, state_)),
           fmt::arg("bandwidthDownBits",
-                   pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
-          fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
+                   pow_format(bandwidth_down * 8ull / (interval_.count() / 1000.0), "b/s")),
+          fmt::arg("bandwidthUpBits",
+                   pow_format(bandwidth_up * 8ull / (interval_.count() / 1000.0), "b/s")),
           fmt::arg("bandwidthTotalBits",
-                   pow_format((bandwidth_up + bandwidth_down) * 8ull / interval_.count(), "b/s")),
-          fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / interval_.count(), "o/s")),
-          fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / interval_.count(), "o/s")),
-          fmt::arg("bandwidthTotalOctets",
-                   pow_format((bandwidth_up + bandwidth_down) / interval_.count(), "o/s")),
-          fmt::arg("bandwidthDownBytes", pow_format(bandwidth_down / interval_.count(), "B/s")),
-          fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / interval_.count(), "B/s")),
-          fmt::arg("bandwidthTotalBytes",
-                   pow_format((bandwidth_up + bandwidth_down) / interval_.count(), "B/s")));
+                   pow_format((bandwidth_up + bandwidth_down) * 8ull / (interval_.count() / 1000.0),
+                              "b/s")),
+          fmt::arg("bandwidthDownOctets",
+                   pow_format(bandwidth_down / (interval_.count() / 1000.0), "o/s")),
+          fmt::arg("bandwidthUpOctets",
+                   pow_format(bandwidth_up / (interval_.count() / 1000.0), "o/s")),
+          fmt::arg(
+              "bandwidthTotalOctets",
+              pow_format((bandwidth_up + bandwidth_down) / (interval_.count() / 1000.0), "o/s")),
+          fmt::arg("bandwidthDownBytes",
+                   pow_format(bandwidth_down / (interval_.count() / 1000.0), "B/s")),
+          fmt::arg("bandwidthUpBytes",
+                   pow_format(bandwidth_up / (interval_.count() / 1000.0), "B/s")),
+          fmt::arg(
+              "bandwidthTotalBytes",
+              pow_format((bandwidth_up + bandwidth_down) / (interval_.count() / 1000.0), "B/s")));
       if (label_.get_tooltip_text() != tooltip_text) {
         label_.set_tooltip_markup(tooltip_text);
       }

From 4c71b2bf9f2636d2ff3c5702eadcc0c02aba3b3d Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 21:51:32 -0600
Subject: [PATCH 20/63] perf(memory): optimize C++ string operations to reduce
 heap fragmentation

- Replaced pass-by-value std::string parameters with const std::string&
or std::string_view to prevent SSO overallocations.

- Refactored static mapping functions in UPower to return
std::string_view instead of constructing std::string literals, enabling
perfect cache locality.

- Optimized string concatenation in hot loops (network IPs, inhibitor
lists, sway window marks) by using std::string::append() and
pre-reserving capacity instead of overloaded operator+ which produces
temporary heap instances.

These optimizations reduce high-frequency memory churn and overall heap
fragmentation within the main rendering loops.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 heaptrack.waybar.2711357.zst                    | Bin 0 -> 12780 bytes
 include/modules/disk.hpp                        |   2 +-
 .../modules/hyprland/windowcreationpayload.hpp  |   7 ++++---
 include/modules/hyprland/workspaces.hpp         |   2 +-
 include/modules/mpd/mpd.hpp                     |   2 +-
 include/modules/sni/host.hpp                    |   2 +-
 include/modules/sway/bar.hpp                    |   2 +-
 include/modules/sway/language.hpp               |   2 +-
 include/modules/sway/workspaces.hpp             |   4 ++--
 include/util/SafeSignal.hpp                     |   2 +-
 include/util/sleeper_thread.hpp                 |   9 +++------
 src/modules/disk.cpp                            |   2 +-
 src/modules/hyprland/windowcreationpayload.cpp  |   9 +++++----
 src/modules/hyprland/workspaces.cpp             |   3 ++-
 src/modules/inhibitor.cpp                       |   3 ++-
 src/modules/mpd/mpd.cpp                         |   3 ++-
 src/modules/network.cpp                         |   1 +
 src/modules/sni/host.cpp                        |   2 +-
 src/modules/sway/bar.cpp                        |   2 +-
 src/modules/sway/language.cpp                   |   2 +-
 src/modules/sway/window.cpp                     |   4 ++--
 src/modules/sway/workspaces.cpp                 |   4 ++--
 src/modules/upower.cpp                          |   7 ++++---
 test/utils/sleeper_thread.cpp                   |   5 +++--
 24 files changed, 43 insertions(+), 38 deletions(-)
 create mode 100644 heaptrack.waybar.2711357.zst

diff --git a/heaptrack.waybar.2711357.zst b/heaptrack.waybar.2711357.zst
new file mode 100644
index 0000000000000000000000000000000000000000..88921cba1ce1ab95825bb77f62a6f1a72e958a87
GIT binary patch
literal 12780
zcmV<IF%!-xwJ-eySpALxI-$mGDF97^Ru6&gijAt@itCdi<yTJ6F5m(>fcXI_LP$zl
z>ZVNYEd9Ux!wYi<9S1%JPU1-XD9tlzkvz}NLuTScW@et4NgkZnN5!c2D5eEdvoMiG
zjHVx?L?sJ!!Xl(4SRvUE*HjXjkmpwz6b++zNn_}y6ceIB+EY*qL~)p=@(xnrNs=#A
zj{M9tgYz7m%p@jGJ>n`ziMT9LlL{}SS0uy3c=6STx1_`5f#X3RNKzSugcw9USW*i^
z;wj8!Y98Vi&M6pK3P)9$vsvV8s4^c>0(xD@)+<@Kk{A^8DYIFKTFVnfhP@A(kHumj
zR_6<cGM9EKu{emKI-ST#M(q|!0UthvNk(kI2ctOb)xnztKF%b;g5hcNQ4Zfqfi7yO
zGB6Pf;V_Z427T0lI3>+-n8@K%G%<<7;LJ&GTx6IIQADNI_r&%rlE?TsK>ygF59%P~
z(Mj_h&>wP2D^f|M77D`U(6BbVN&ONf2RR)KjB`VnZ;nNgxM3U#9{S<ZI+>J(Pv^j#
znTgmTsg(`<NNSCVa`<G&7#egWi8a3(9uUI<B8NgjA=hfpV}Jr81&N7r$oC|Pgpw@k
zqKOWNg&~5E0-wn4(1rRDHUkg<fi`F#^Z|XdAmq`?e2#=4bc}hJUQEtc31?g+V8m2`
zEq*D^Qko@s4yTslR!vaKDF``;=1^KfX=!n4bKLWiTZvK*Qlyxs$Z5*qIGF*&^Na^Q
z;3Fo=@sIKcOC+xFhZi43QoVVU!}BDQS+bT)84{@-4}F{g$s7%TStO|Hl#EK0g;W$)
zG&KbUDY$~Ya0#l_2Yyf`4j|?sLA4&PyyDOZVsMF+ERff-&`_GpT+!4J>3gsahd$0X
z36mTVsYy*BhQxGG4$pDeqfnRxN<3NiyR+KS-gL}2Ks<v)Vg_QO9EZeWnUb@liwx~i
z1}DCPk{A@v6MN7xP=*|3LY`QoICOnx&Lj#68x~SgED9@1D@u9tAxMeH#jT^)pbxpE
zN%3(x$#Leg@SY?^TF7c(7EQrvQECIkGY|;mgr1lv3LI+C1ICAx$nkzoh9+tjl{^ba
ziN$-yN$Z)2q9BJhJPqP{;KzI#<dCjlW~#^=h8!A37Q-xWi7w%$XC}i>;XqG<P$wQH
z9`L~+mIWc>VTy@ztQH#^BEur~;v|+s?L}G^A{oO-O-mRzKs*EHIhIyPn2Csbs<alx
zlrVTbEJSrri3i4Bib4y|aU3AzI4B22N#ryWUNEc81!<<J31%izF`E)O5BP}ajA%@h
zgF%|3h)kkzSWdy5B2tLrn}bv0a+s9oX7`|v*(@<pjs{`!kq*t2sLg>nOD$BEj8i;`
ziHY+~5uF2%_3=x>B+D@u3O$PFXo;d|GkI8fB7;N@b-uy?q5qWh!Ii=BfDP2)(6|gJ
z4RsRfK$t_<SYQVB14mPRT2t6NOt3!5Qq%i`e8WM$;ZVG!$kZ>m7rD7$s+2I9s1^Cv
z%rkIY93O~e4m^F7fu?p7TQVsQo5Fepr8wL~3%D>a&lHy`6-YW%@k(<nOoGWNk{CG@
z3Q-d!hPevTw4SG?CE~<D!ND5vL7haRP0}3fmPs}RWX8By9J3zjNg&A6^rG+<&09Fz
z$M6B-8N@_E;D8T@N{D9QC>%P0sObySk_uOl-l9qpBQc9bH!Fq66j41uJk0|?6ecFh
zF}tzEl+?#8m`p5>3{N3~uN0~fId3wt2e1cxKm!ev#6&p?&%z~|Yb>9IMbDE+2Ss6$
z1>YykEMEh}Gf;!ZhaVv17+~n~48$1|<&Y9*K2t%8i|DxDBR(wrNaaXG5lKkH<botM
zL_}qS#REQ;1>qzw4`pbQU!KSfyJ<;gaMsrd!xm(=gsIIGLnMd~+8gxIFp2mal(h~n
zCSH}{u~z&LqeW4g1yX19gP98s5OPRpSTOD=_(7V*f+@)`Ne0DK9L@<oM8<_kkT+;8
zCJJ&q_)M!{P>RGT+$Ux<MA4j&W30Jik*m(y2K;OAdeDE&r7fJK7p{Sld$XK`H0wE;
z@uw%7qj<1-;K#BYAmo^qMI#-e+APN`gH$ZPh{#MR8VOlMOf0k>Af7=RzyTjkBN@bF
zI2MCju-MB=L{UYDMWi@SVMx|=STLd%PSv0fi6lH|9`qp)NF;e;q8!SCG3rI6P*4g3
z62YXPNSuV@z9e;6mWkOuM&m)_0UroLnay*!TP?v7r$t=w>3JoIx(zI0R8tm`;i+pM
zqj{-3Xg;8&9t(UvBq|pc(St<kz-Cb+C!9sYoJGN~+}g)b1H?0c7@8<DCW;!Y9`G@l
zR}?QDiAXItaR)9=@lxWdOBALCDv_heW*vR>GA4=w57BtIf#QKWK6<IZ14(K?I87XQ
z8r#P}JcIcNg*pu(CW-<I#6(em`*7-Dt@@x!eCS~Y4mDr{J`VC7sCimA7S2nYlQ2xp
z(m+=aie}NsW$`Q+aT_E@0qP*2M}a9}6j<i=F?fJ@28d@y$27ns%GQ12Kmke+1s;f@
z%YZ~6Kmq2LM4`+V4hql(QBYu+?_<bX<=0h8@h-q{J}O>PU@FN#RA8_R7`}=%#Tx|=
z*D{_gFy7j?Z@9J5$!1=G(H2{4ZDW<G<!c#~uR(|Q+V!A6qZ6VCfk}`7r6C~Oyz9%4
zyq0hGLWYCuyevMQQ4;8Y@(}?cY~`+$S71=ze*4CB2^me!$>`x1!b3k*oi9JWLw~-J
zX^n9YqprYk-hAI%fx&#a`#Rs|%XsqRHRlQp<@?yaQE9JazFNV&_r?WXzcnYIJjBrD
zCo@n9v{67Cf4P?*S76B4JL3wBZ`iN*e+7o?)~r`Uw_bic47dWrd%O27^j_<?0)tz1
z<#oJ};gDH7+0DRQDCKRukkOFwPXt4lybQjI@1a8<CUMET6kJiM0pxr$K$yhY$NLzO
z*Q@dtA7K&)dI&Os9(o81!l~b{UVd~dFrN4Mz5#ie7cwZUa7~9oi6apX5}^<zNAW_&
zeCxdGq5Qba0^>Q}$yQ)AX1sVG3Jm9FX2rgBAw$Y$>^TU>p#o#=8+0vQ$Y3nF#a@9i
z<<5nSIMu(G3mFhH2YCfXT-E!=Z(PXu=AJqP1nw_nz_lEt$U6w=Av6OJeV*Y$Mx)C8
zQ!6mus<v;qeG3_nLHK?lAZ^`3hHFepgrYow%0zhx$j*HXwrwG!wb}kD%0MMZlpzob
z&ld>DGTz5n%N8=2irnJEgYyFk0<v-+!*?xYthb97&Q;k%1SAPDQIMtk7`?ub;WRGg
z<-&ao-d@OP3E595VUo9xp_Ugi`0ebiaC)uZx>dJ{;m~J*067mm1Z5JIM$7VwH;dwd
zA9Q);fG%k;l2-Mfa;k;G(_q0xhkas@^F8VVKD-%emgFg9X^<!3&swV77KgtzsV-bx
zS_3PBAP@xM4$~|Yj#5}l!!=UTL1Lb{5a%i*s2FGv4MM7kwJ?)Qi4>b95vfB&s?%JH
z4q3$XONR23L<bSQ^_E&#6DcHX8Vr$2n8i61o&+ZlBr@ax1z<n|lzgQgKfxtgShl3_
zC`Dqc74fi|WHm}%iR8JF%WUK_W8=JGvX)A*w1H75W+94(rZv%Gni$1m;0K<OwNMaA
zAq(uh_Y%gipdpe9!^6`;q4d#wKvsRw#DRWFg@nJxIu#0(rbz({$jb-aLSl+SA}NVP
zZPnIPy)_cEh|=WF%S63jq<iMTsFKvlJV}gRf(UcT5-G2m0+Uk_J(~#h`9SA=M05^J
zk^(j>DsjQ-6ET_zT#0h&75tDS5XDRmN_1ueKPZ$aiRVy>#-Ly(87(Aw;-D~v!F6<p
z$0Xe1m>8c_Xq;3TpIT#h#-esC;Z$T%B*j`tQ(N=6i5_*i$q<F(D3~WTCW(c5?^GhX
znhXeQB%O%@A)I(5m?iOp)I?OG;jkbGqfjXJ9&3te7FeQt5u0QY4;GWR3T=IRp2bgz
z@+fBHi?p<s^r8?QtAqJvN}9tXMLGCmdUB28d3G_9nq?_Sg*QZ5)TQtoQyo!Gd_*}#
zCOHl>nWLQHSqkmALPeChM2W)bM1pWK)ZsV0xfH94rYa)AB|+r?5niy>TMCQ0DU=kN
zcaURwr986r;Wf>i4v9**QXlmc9`bOusGSFW&_)4K>eM4)rz*PrR8o{w;h+#_6(N6E
z&78rosN@Tf4|t%C<O|R;Ohv&N7^w@s76qB*6!IAg1qSh{(70~2G4Q|-M05tA1EGy!
zAq|D9FvQ18IdpSqMM*p{YLuo?)G1YCglQPUG=CsW0}qp&Rjq>|CKkx-i-#@mX&g(Q
z#q@MRLf<^eT;SP4VaH-R6s1}tsi+kzY&yk*6H^*S#TOND77nbHWjb0}rWbug6e$ae
z<tnqDNEHh6zZMiomHe8Q&JFr#4)_vB(^36!qB*58JP%wJE9w?07AZ6GGZ5!7CAc&L
zGsS-iUnIGv)srWR>MY)=g25@U8g&X#6O#!SgnVgXd}8f!4AK*>DH_76Qw<TaS~OHe
zji3Rv9FE~ROtLVs<7xuJX;LhTp|BQ5A&-o)f%L6`;-je}n<FvTT>KHKfC{K!&r5wP
z%VRuQB;=sp!07_UZ&#(nAT{KmAjq@~l5_scy_8r5W&pAHfY+dv1R6LNYqABxi{za(
zRyc<xMPyjavS1t{)wl4)QIn-nTq9#Nm3Mf9a`?nyCC=ji4NRQHetCy7Nk9K6tWhvr
zJZV8^(SA}A3M?>xh!k@HXEN^~Q9jeS6A69=1H!#vD#MM5s$z1rHBbkIk_XW&2&sso
z#_<H}v*Mkq%hOO<26m7MnTrz};{hKO`Q@j=B4x>*rli#-7FtD7)7}q=gYStJkKzTK
z1XJTLh>VY1NKcA>y~qltzay6@PC*l0zz2Ll6P+H(O>(WpbQX_n)Wb~9YfUN2Kc=x)
z5b7WvXJ7#}C3Q+>VKxT{6|0{+NYc3iQm72$(mQo{s7g5BJPIa(4%mjM6v#w}B=L^}
zbIurJj5Edv*{vDl&;Os_`|y2llzSL!uE22L-#dM-!0_+yef=D3OCCnghrO@Y^{zI1
zRqyQW=IHb$=X0>PnXIihMk>2^_C93Ts}$^wat}kw?w!4@ds$B=FyiZdulKd-@i1P#
z*ZX=Ml-;kH>*Y<pUiErsZ!_6+y51<A>z%zX_b`}TfdO6b>z(f!^uutuo*zcbUez0W
zo$GDh%e<HIJPekt_pR2VY^}8xTWiZ>jIH&)UdLju>UIY^GR9bBj77#6i>y~I#v)^k
zt+-b2>y@nQ>n8s&TI^Na`+8mPY94zhyM+w)m79#++e~`%>W#4lhFZ1vVGE4uExk9o
zJ`5GRclNgKWj$H%>)zKZnR1c3!=Ufp`+D8{Ue!B$yH&<bey?KP+f2sqjq!VXAF}RM
zzHhAVjqWhs_deD;dt3Lio=jj=ZpuBmX;X}w{5_2J+{?Z5A40d@^F0iIZth;kz0G@>
z_cHEX+`D`(ZZfVtj0pc#t5&UgS9{f}Rm&w+d)2B{SJ)e&YSpSMth}#lg|OCItH6Nu
zRaawF4MJFJtrgZ<pSEg{Qc5AE6jI)YEifEyls7s^DW#Co2`j4>AB1zx3FqXUyxrb|
zl}X5}81puhEil$(-uPBv^km*Cd0{`^$Gp)UhMZDL-uW^@`J|Js{d|?l!}up9OJ2vj
znzzTRn73PdGx9c*Eo0=3FTTk8uw&$n?l9J4j=ZgTSx*)tKd)r0Eo3mJDm#pBI%V`G
zF#dTJ{BDP#-aqf-b-b%ZCZC}Vbs7Tn)P0=M>il^pZ#U&e-HdJp20!n6$apWOn<zA}
z5F~X7NQJzWEo8W-Zo20a<&~ERWdKox@I0?b>K<j%@ivn(KIDxN@;-#TkT*I9A@AgE
z&C7Z!?<L&|3<Y^#?;G{;K3>TdGTQg#C0Fu3Q98<`TY)hj?~D6}e7uwQ7gHuBZJr08
zqx|N06>sEy?_Q^?i)B0v=6Dz6oxIJ~^2Zxv^D1V6Q5|*DN%xMov4xD~&eB<w?^a+y
z$Im(5<xkn`WCki>aS-)k-hsCAJ{~7)c^JyAz-W$l!F_|d<#?M>_-uajcD%8zz+k6b
zZLPJ|8ZWbjjQ(dWmv_EV9OXCOXZwb0ypy-K=afyh8gG1W-FRnPfuR~R-YFR`Wu=&!
zbV9@#Rh0i4<c*76W4w_u<DHZ>W2RW8lCEd5t-zRzcfEZ>F5bx-*Fr{<Y_5lkH@3Fg
z3JkV*@lIaJypeh9;{C<^EG`2KB_M=txSERcRa=2ksq;=5oi{o=?_?`59PeEI*b0nx
zUg^A(x4qKljcf(RY;NA!yx)rLVL-;ac;`O{55qODdcB9ynwvNBI^Nd2%y}74J`BcI
zU{IdS%qy8UGQ0H)@?*!-8*daCi=CS%vlST3iYuLp+c(BmU`WL)U-7mxe2O<JR;+lx
z6}w`^D-~~4%$(Jgvu-=fSU1M5tGL$vUMnzMZI#tky{@|UFy2~$(RJ(2Un?+Ft<Vpn
ztrZxQuA0vegDpzwI=b!AWpr7iyBOW&uIOsYdl+l2z*y92)5%oPjcWx)opjDQ*PL_C
zUQ4aX=C-rXIjPS%_j^`4rHqo-LPlh`no5@|mz3M?n%pQ?v6TC*TuK?ET92*gF~;aT
z#@IZ@xZl14gT)m+cH~%ld0e^vw|&ar7+YY(|KIuht^6?9S75x~wQsoJseA=SW03bS
z>igTnpwF*<9b+u_Fs6hN?vxyva`mPSSHhj`yc}-)h75Op!(M?=AALI|N1iU<KlpaG
zJJ;UE#@>26DeK2iy-MXjZyJ}A(QP|FbQ`-@U_9qsbNkJ`0)x5b+_hsDnW^5xP`v^}
zxvj44Q^{hb6VmzMVNlsty?rCTjt{=y!<gJwt=87n`5t@}?>J9zZJRG-P}&jFMe<Om
zwPjB0`uD6YTWwd{<qH`Tvc)(QViE$f&7*tMco?$V%C&EBQ*GN9G8%-FE&D=-WNyJo
z*~U1TWNg2cx9V`hXOKPSSYulyeAMA&Y-#lNrVnitkWW@oe&iJxi#coNYbA`bLB~w7
zjq$PB>RQG723>RQKjZfxuT;XE4`G8d?qM)qfgx91zxK7Se*p$ty##ogWC1{cX8~Xs
zaXwx<A2K!{%eB$>jh1V>uH{<klyTJ=D?fS|@vVKl?=><A<$E00#<;d6vwXAuFAk!r
z-p6opE!TyN7#AyApP(S(qId|+zyX0!Jg!xBA>*HvZW0i4+dc-1Yb$jLp+ro={yxTv
zYw2TewOPNRa*AswoxN|eHtQE8^pc=VLR>3bLk8i1qf7$FwUJILA(U@XJjx^x;@V%_
zq;&K#009t~k6^$)x_n=){OD7Zxo#f=KK}J<Yh3%Nd)$sPUlv)x_86dmm?#9o#(j+U
zc&*}J+h}uZ$ycFdq6CRD1j0(XkWu-qCErA$ClHq3uU-F7D|^4z|DQ_sey#sQ`s~5A
z4k4tDJ-D_(2o<f1^@D2}gs`?|{2+vn&Z^#f@69#qTkG#V8K1uQUhKE#d(XXeYuz~q
zm9OZWbI+;u&N=7kgwDCvSbVLu#^iI?T5HRjx7J$o$y#fyC$lfc7~}b<JH{AOvmIk=
zUu}@r_S#qJY|7Co<6Nsgd`@z+=-+s)U2EUkC|Ruap`t-Z!dm<D!S>Q$00USB5CT9O
zMFb>300P8BQNS*TGE&+oAc*<I`Div?`)XbL);=kluXR$w_9mBkYh)Jv5hj^T5@Bm*
zvh~LKER`G-C}9DFIPee%3@CsB9KZkt5cVVQ?;CL6c&$2?`-X$_8=LzEt4SFzZ(QrX
zK^d=YUb`ghrOsNEZ(usmGxzbSI#T!`?*k0SD-FqbZ9B@5LOPiRNQ9yk;88qGG64d?
z*Rov5XiCmE5hiJxZ@>ad@<-;&*H%V(H3kpzqoVu);s68zhdyALuccA7g|Ib-09Dz_
zwRl1WArKbsV?0~iajmS+VS_+09oOt<1?g+<c^>b5jK{dHg|RYy&C%!SN12^uZpyW;
zR&Lp*Wg&3yV|=e|lxLHyx%Q^YOg?PztzGje7ocwl(DT)K?Qg3&#%mS7wJn$9UdypP
zTdO&TG87?D=&2(KtoJdz*Q)toTg@?u1R~G}fhZ7m{<nP+er0aJfgT1S3ENF)bDniE
z)yr4@vbF84TD=HB3A2C&R_<fe#Tc(uYORf~GRhu>e(g7=XoK<%M8sSR*@SLE387Sn
zPG*2Wm823JumH#VyytlBb8Fp_OS&iDk|=aS6d@1@3s3-ou(dH<y!K6A%O3VR`t8Zb
z&<0Tn1jlPvduy#t_driFQNmOG7u(mcwdoRtE?#S=<h82TMk*JtRc-BC>(;iOQLR;L
zBRlu;)!L^%&L|_Vop144)obJ0hrCv`wQsFk&}WnpK7%9=0U@--Yn7suIx{xobj54^
zla0DBt{&k+Mul!Fx)%E?|EcI<@Zws1qwizB5JD-{gY__=FG_u%uk&5a8>PO}LAatf
z%IKor)Hgc&Dt6y@_I=Sex^{No>C^X3-{){4gHex79>()IeP2)C)x7bXzSFlGgYe&d
zn@JX5`o`GotJr-X`l{#~+u8Rq-|5?YSx?5&qwj;?q_eMYd$aq-X7~MO-{%{h$Bw?!
zRdip63mFvhbc$#Q$Wq>?Wt~pxl+pJ+Uxo`Ab55rS0a38uH@o{f-_^YJ`zrRn^L@Kj
zSKt2-HiWPtgs|E7y>E04A%w6QLf_}~LFR7w-h2Jto2|iq&v*JZll|Ufe(yPEU-iDx
zv2)J(vYyPj^L;Wh*d+TllaTqw$n3t;_hI`!=o=lgyKie>){`~g*S^o=qpwNk<|}>c
zlFjZLWBV$0--qq{e4}gjeZG_VHs<?oG8N%dQL+0zU+0TKMs%)gzC$5~5+s8lAS;=#
zdn(G;q+(y?JAIqUcHbDAeHFX!!)9Lved8<kea;qCynJ6T-?w}vW0O6_Yq=|Scg61R
z@a-GVeWN>!rP$rwm$hPdclY%qb@eb>v9Ds^H`{kLZ|&{v{<t~C?W@{%`ZlY+zA?71
zV&Cceuzl6@jqWgH^?l5D`nL9EUD?^$`!VJY<EyXY#=g#XwaU)U&acW=eU<O@Z6@1&
zWA#<+z7N~?Ip63GV^!bhzLYQPs$BU#U&+*Kv{vP{)>><=wbfcHrL|UCYo)aIDpx6`
zlu}A5rIdD~lu}A5rIgYcA)}PeN#~q&&hC9WdtaM#(mCgxbj~RiWRub<rIb`k8JA*I
zN*Sk=a!T2<_hAbRmaSxObTh^n<BT!B2aHju6o=GKYW6W`lrmrp$Up#-Hd7a9U~o8=
z26C$E4io?(gnEQ_9gZ}yB{Kj3NI(PvvY-GK)^c%bmyrMdQ7>2v(Af4`@(-F;*UQNV
zOaq7Rj(?8_c(mXT`=s4C`;!7p*v(HSfpQdVX@Fz7S=>$gmiA=T`LTUg)|IQk{KhA7
z1!?mD9q7A6*a3Y{oA`ol<M-A~p&vrdL82P+8`#!El4kpo3FMF@hcU!kB47FXLuej~
zwgn)l{=FS;S{IXqft9t&dY@+jNUDA!S#Nd4gs6NZ9@~7jFT5B?bjYl40KzF(tjQLA
z(<m<+#VAVSdje<lL)#n_vP6-{aQUWHU%}awTbviSo|o;0qDS`gmYwniq@!~Bo4>w=
zvMxRlla@#X{tRW{Cjwbp-C)E}T|+5?F?<|i*IY&utUIG_bl01{4Hx99Bwn+X2B|I4
z#AEjj0Segxf#u>-Cv4(@iBe$*Q2=0}Ei?t<F9Jl#8_h6ZIB$-=nA6+iCMj#-&LK*b
zFt>hDNG|&ZNqgb8N^S@LXP4noWs53)uqc*-=PaNyyYCa?Aae=B?R$n|&%3c*k6imA
zwx4tzQ(eh35%*6mkd~W+a~(dR=rqwo!1!o}64JZHLMsv?bCO3_n&K^YH+JcOBhP}G
zmzgiH<Au<N^1b}#RJy5Ng?{y6*o>yrkwtXGZl=zEhd@s$8WEEyqSGJjz*D57qmStj
z!u7`F`kz@t-uQ?_d2@6c(cTPr-7LHwq@`qO9%oLdbLpm&`9AyDuR+XvY&rxy<jF(>
zSIN0UlgP$hgAU@xC5yNV(P74l3!xI)>Atp6BS}i|za11KT3rjl3PcqZ%Nw*~M-q_4
z`3c)?SpG|GjG%lGteV7R$S5%yL=PB2@cMgoa<LH=Hheq#<uhEEi|XTAss{lLBF!@U
zGe`8eUE?bdh(+2bswFp{<}_Ie+(GSZ1ZaS^N7DIxl1$3K6Wa?Z98Rw0f%WSPQ5k{j
z`lU7yx_w^cd>Dd10(_7OqN-8w`7iY{NvyaInr6E<RWCLpxm0{=n13TN>C>A%^y&zd
z1tb8T`(0Hogaqi(cT|Y?KbKv4rX-XSn7|m;LnhnkCcwge!?D;g-;RY$C9tq@NM2|@
zOD=hb&w2WHhGIwJvw9mMZ9<fx*{KK&<TTb3{K(G){=%9HI^Tw%zLYl>mV@0EvCwVV
zBt39vIfOE6?6G{WQo3G>)RldbB(X;}BTeT(j%Et?2-iIXl0{t>ceLl~2LA4fL1$!0
z3byqn!Ky>-8>y+)sSdR0nv|%@)Q?sC1o?j!+hgLoujW`{te|P3(hw;q(V%yX6j?dz
zZRLE7sn6n^P;o{s#BrzFejXe5z*<2|_drh;k!w4Oi+;5W4LNGpFoTWRLqIr)t3qUS
z75WG!WzRZxM#>B!h{tD<-?KqJVOs6z5lBg+!t<^Yh)kGZAn#MlKsDh7me*}m?qLa^
zUc5$(Yl^4@dI{T@Ri--OzaZ6fEk6STG)DwQOB_h-;fJId#L4WidXXj8xon&hF)B=+
z?29|z!W-H%d|5(s$fBW!9FTm0`yYT903!ma09%vI2xyGhJ|DVJj!-)=6eWOQ83|x;
zPM^?J3wSx`kF)aj_;V@Hrd(F$e|b;K&3hmLmReWK0(to;(m{|n(+)PZU4faQz88ou
z_htn#kPc%T<a6kdY$67ol7}1;q#1^-((_`>3~7WH&fPaUI$^PrFpt2o&LMIo;4d-?
z*#w5S3If^CKzTz)w<Or*&@4)XjfA!&1H)!XLKHh~FU74_nI%2?hp`aD!CebRG+wMF
z##~^KR5w~!khl;k(KBJ|hWI#RL5U<3n>_d%)NQ~t&p`SN;xIrHRFOtQBD};Ic++Bk
zPpTyDG(9GJ&+4r}zhrS@w8nF#NnN+l#j+pIMzcU}wSdtf=qQHeib#|*oCuK)*hO(@
zvz2>Xlt#Y#bP3?b1QG0#6%tQ%!G54f2YO2H4^9Ew@-{HfLNBYC_j_6mHut}pER+X*
z(6e+J$Fvb?h#B30no&K<rzd3#fK3d{9>Gjs#^;{zC2t8`TqfkNyS4WG2Fz&*%*b<D
z$g+uB^$d9B^KO)1LaPgJm#63MCTTo>XF$P7x?@ePE%zPKeVr$bm%$G|e4=k5JiPcJ
zMmkyKdO$@N1836kfmIk~Ci_Vcc#vV=Yn*VXAb_Kg_SK#JTo8R)&^2YBtVn3$oS$Uf
zu+E?_T^^BM?1YPalY}UB_8c;MHc>EpQ+|2?C1R$%G;t9@cMj#Y{*j2VBVxx8ahS__
zK3N30iJu&Tak9gc1hdnh6Ti%GG*>NByRNyUJ}%$}*qFpMbqzv1+Q>+N!PGzPAIv=0
z#s;-3R;krecRFVYB7XHEgv>yTL;=2KbaU5~+z&OCZeA?asX9{PS(Q+ig<Tdd27@-M
zymbC?jrc7?L>&(l`&w9Aaygtn?SH`{$x1|s!ho_W{VT$Ah;@i#P@(uMi~ZzOLRHKU
z9Bh;O-l4RD=!+|JM^__usi+n3H5uk%V`dytkwAiL?6aZm-h4gZVP7A9hpP4Q(II_Y
zDn)86)TTUe2PIa^-ZZxOg=zeSsEXMtabJWXJ3GPTXSxP?of0KZ>G>qfMa`o5TK5iS
zDnua0<?|u{kvNSfso~k~j7L3E)4b1jN{VtUYLo@T?P+Y@g%t)gK6V9P+Cw4s<O}^Y
zfRNZ<VaLY@n`mM26~r7Ka77Nq*<;OKLSn4+GoC$Kfyd;c9|MNrMzk<xN1zj2BoZ-s
zeYUgK@dz|hpqDw|9QYvRTNj1{gA3<`u<{DmImoHH2*OGYcZ{fs7<==2Ob`&b98D!9
zBElW|Y+x{HeD5MiAC+_3;8NR#<|QY69N<SpZr)8So(br@-^V(aCoLC}99{BR#L4e;
zy3=mR;*C^IY*{e|IiMbMx`a)c)4sP2mw6;Z`x|(io0lMTKjH%-p#Kz~>R}&diA0Hl
z=Qs85DR{F^<vpha`V7^<%9vTKX<Lk)P4+wBF*`853iKh%><d-wytV+Wk4YJo@)(!3
zKwHqrwBUBXfVCaK`?TR|{$=lULF(*Oz~@t7{E~u40pSwdW60OmFzXK&9oFbPNNvSX
zk!f|o_}I(I4Owt0#-9d+HiVU@;ArnX<3YsPM1Y8tDotP_Zc0eXwH`mNMpclIbjKYi
zLC!|@0lBF*RFSvBRRRpm#sZ^xHN|{*F~MDMc7E);Y>KKZl+KH036k$vh+*y1q;MT*
zsGHYA=lsWqd01#OYy0LYsQlQFL{DH5?H)hGYzU?^jGWPUy-5^Kl^6%A*OcPt749)Q
zK-V9cPY4Cv77cAe!=!{Z8Ptdf!LSGi0NU1}u#lLr7Yn>6q{T61aCBGF0fs?A<!A!P
zg(saqZ#+X^r2objk4|bZS+*2IsuTh6Ff()zRb0M6lNEmt>qR~2b_3KA+g<YnMM$Aw
z9Lv3wVw_14V=?jZBN{VeX*Y&L$AkhZrvY_@DR^cBNF7|&0WI98>5m)EKv25Fn;eJ6
z#pL3m0lyugB-l0p&{o<=0q^BDkBn#n{E-?vSIQpoCUS{<k6#55D2U6e@d}rQyb}mU
zboO2}bUl#l8;EJ=;M>qoHlo(}9)D*_jYqE#>rd0vNg3)IQwin~69KBBL2Ti@GXCf>
zBsvNyD+T8L7f_qoI>Lvqaj@ZP2rTxtkjJj_Hk{>JB$^;i>pU-$zX<8mM{%7t2(YJ9
zT-ATT#;K|LSpf-OhU7Uq5{U`ns$!mrbVxxEBy4Y*3O%WyH7aOUCV=I8It3oVa1Lkk
zQbfDNz$6bLA;m^VQSJ!L^$Kfy9)mC<1%!Lm7~FxqqD5fz)M}8)Jk4w^zx*LEErd%c
z@qrRzI*EhjGc<D&G~{ERpvtVGQBVfLt`Ztze}rQDIZKB)ZUDuP@<f>pqP`%|I0In@
zV#MM+YHVJ-(5;qGy7L(cO=3n6E&tc?#F+g7GpPWyoiK4<OoR*IMu9M29I)UAje}U3
z7(njY$68+@T__bDg+Hi2Hsl>fzdkfGg+av0%2vzbTMf0q={i57{x30=rvkJ}d|0fp
zt`f?m&A~%i6x(wdD4@6q5O|19I_B0UX@M|e&H1Y+IVeV+51oHbq5_n|ei_T5kxM*i
zD)vIIU%9eB<d=;<SK<bR82uXe!&PPmmWW17XbHWeiJ+c6wdXDE>S!-jlY=7}4-+HH
z|F~aq^G!A{TBaKAJ`JOb=OxzhCl2PWmm}qJ{DQWvN8cuWjVF8F%}i;Kqm#b`s-lCT
z2n-XD{mVp-G>nH4F>oZcgyT@`ehjGXmuV~TPak~>?NHoGX~)(g#702DMx_Kdn<A$;
z(|gO!PTZ^344I;lLK9T36dXJ6?s(+FV&!!gWsW0yfb}AOX)mU<W8F<+^?>p@;%y=p
zZ2luEckxp)DJ62(v(=e<3&Je~WUkn-aI+L5%%9^VKV6PfCOnCG=EVXNNm=ivE0^<9
z3dVQH!WC95v#tRFlH?5dsd(=@y^6FlB?<KbEzc&iad*P&)oC4k+~Toyh;vZ_DcnGO
z1T5{)gj1|qD7k>?-8Ah5wX{2h*#a7dcch{YwhJl<uMm4<FEjQ0qn3O}!{><(j|#(k
zT{13%7*ud`x?auv(&A#h#7`p<Yv;&KnhQuM>vnCXZP|qr%wXbR@r66)AzoDpYMFL9
z3EiBx#rT=_WmD8gTrp!A#Q;S2-kYV4!GKS(l_g7JWfAZwy`v&8H6kQ1jfB&{xV8h1
zyr^IcynU<*_}r%5U6gG>ZK>0D*j732iwfh5Q+9)n1OW4u+i4eaN8JTv!~oAj>$Io$
z`q&t(Ym$O@@@X0fIQ&jsH4XkCj;ZODEiNF{B_s0X#jT+bx*Gh1#;u}o!0#;KxX@IY
zTf1U6*snS=J?EJg_wz@=zIN@cbdbo4@=<cFk0cN4?MV%NBw4Q|djf5-RzCU(E$htN
zfi)5I5fkbi^tPdv*_Uip2W*mB&&&Q$(U~O{uly1=;R;rbaA_hoVQqTcj;=mLQXyxr
zk|Ip)#skF1Rdvz<|9X~Krv@oI=(W#G{!yDn4~Y}WLl_LIy`x&jM0DTG_plc-#I*iZ
z+ibOVnF0*MumToy>pXhf2J8a=Ouu6(BIFqqkc%QH4(e^o(|b7{VWI8A&;rrTqwu@@
z0p3^Bnwzy^+i_j87%&S%!ipDzUx{(DpJyF|gazFvyLxe1YcC7KpmZirm#@-#357bs
zVdh7aMcQ}d5IrE$W8XK`^G%XoRF9M{K9ZuqPXNCPtq*P)qF{nh9|XF5#zM1N0^prc
zm{}pDw~2GP7$*5TGf}45C&z>`o&R%B0H{Yn>xdNZ<uFMoqH&?Ala|)p$sH2}sN~V@
z5Gd2CECa5Wgf4%OP14oZt|*r6m}77Ci9ZF@+A*(_=yO9(Ypk4s&uoFkykBHuNSVM)
zJ!vB!B8k-3b*l40(Lwz2lNcEVrD?2!iJ@08d6&h(?+@)VF9L9jA!UQb?IVpPFQ9E(
z#P7|6MuWzi@x<f$H)}fXPc|INkxcEd5d6(6vjc{v4?ApK8Hxplc52rQ455!rWjB3Y
z?Cchc)r_fRBtuqbVXuKa-sCkcQyW0>8~nh+>=FhQGcf@85IKH9z6JkSMgl>JSq6WN
zS1HETo(o2(DQ+~H!P49%1)ByvD9v%9H<@p5>~<m`76NaU>of%ap09^cn&)ZTTI0&&
zM5`nqRBj<vJ%|K}@Cd2tSf1q^8Dt#|r}1e;hlTQ^&gl&O>;Tw5x9}465ibmpZ}(^y
zvtZCjEL*GRQ?__Q@3^tmCdhtvj>VZub61Jk=ZCh+5EAwb7O7q~ww1SaDM<h+X#H_R
z<jCzohWP}HR-w=Lz7v^_v0u>_ktQZBnqYWWrSx{8uDbrq*x?R(1#^nTxZq&+pSxt(
z<NKEy1&e3v|GV_5mh+JE+4>*mDMTrBczt0QBoVAvK^Q&8PYl2%qYCkRCo8tHLvVYJ
z6k*<_>wABLub$G~_P~b+RWmWvV3HtpVT%_@F!{irY*2#hExX>8;+R-2!cB!@UIY)@
zRj;I8i=|+zj6v;GfI1e(5eekQV$Iie5I|*)NoE8diy$MxD!2rO+CJj~4&QpI5_&@A
ziH5R3j{E^EoRmBOMCO{4!jfgiM|l6MWoS{KS4rb>^bZli(az5ttf>|I;nS5oHvH?A
zz)1|nsdZl41a<|ALFAt_{F0`r3_g*qtE&%R>V{+YoWv=s0xAHCB?!|{cKXv&H7;r3
z{L^9G3>Y~T$hgFw$@XLLHq5LIj)N^i1d|+f0T=THU{9BDpO!9Epm$BRy|@T;%<*m8
zbM=S>*l%Lun&}0u&=WM%1&D*L#r{3{<r`7~j4Ui-_if7-QF56PB7!FX94=PyzVAky
zqUb1EF!Xp$K7uWQh2BnCTvZ2sR~2t4Nvj5Q4vwe=C@STNN0+6K<ZlC(!g(vtxt-76
z{~dcJ0*f&*8b|Fc7k_|O*og2uvzavc#Pvb}z`(oNvUdb76ep9jjj>>%$yBMxLoum-
z{N+1V_lncOTu^zFSxzkT)z}d@Xp3ee`FUv~eW$3fjyj@791x+G#48US%A>}8>V+h$
zNYpn;cBPmj4n8OU7lvg*STc*u+f^@sPneAiQx026FzHCuoVR(z5U*vkAb$525~jC3
z5giW)ExGCI;VUEjMv0MEtX^f)hX;Xf|FyuIU>n?*3fbY3R9tX$i-SY}+y5&-xY1ay
zU#xmbibl{vFW_;mI%u&04g_}tRRJ(~oD;;dzCg<+u;{gs$XL4H)8A#uMsq!#&X-Z-
zF+%aOy<W5-czTjlM4<)%?E8JxPdE@9zzvRIIcd)yYO4aeO!6$&eh~a?_@7H!$i(*{
zxw>b|K3Kqk!r8bOh%`;0iwT;el@aF&w}J~^zzvic9A!@+uxrbVS%(y^Xy?)VZuKeq
z{Z3cR&`ZUM(4bV`nB<Nm(~=H`a@Jtp!K_=m9<|9vNCc#udoR=kzW^%_4pw_ySH#j0
z%>)l(y$e~8%k`8y;G!qat}Yh7OZ5<2ksMo@75%UG8KDc%^^PHSo<w(WoA77iX0;(A
zI`VfCm&FSSZyk>cn}}#}r(b{%El1NyLX4Q{GQyTraLZVUpH}Xf+I>&Z`6EVeJ8Zlj
zxlCwZSPI<pmB@~GR;T6|=!AeUMTg&Nh;Mfe!1&{?mEp;KUAI&VDlIYBV}fvhz-tFS
z^w2;nW%e@<4Ro}vYg`-|MlmZiYGKpdK?2}5OnViZ`*1r<3Sj19!&3#}!WrcWZGvSy
z61bFHpgvIjCO4soGqEO-xkWN6p_J-{FvXMP&|dGk(clVf>(-EPR>R$zVgY412Gy-$
z<hN1-vI$G~v>M1_5<pE#lm+Jc?ybR#V(JlW|KL(OpwsD_iEaz%nPK`N^}MTn<6hWS
z1$Yhc=RRC{TYwI&mB@0w^6c=%k-`FyMd2E7jFoxuK=)Ys@a4mL@^3iAwxAaaK>Z53
yyK-veLj0bnNHqW4@W?1j_=`ecORo6k4w==YDq)pzyCRH95P3fE`uzc9Y|*2|=`Vf&

literal 0
HcmV?d00001

diff --git a/include/modules/disk.hpp b/include/modules/disk.hpp
index 1b4f3176..b576e19f 100644
--- a/include/modules/disk.hpp
+++ b/include/modules/disk.hpp
@@ -22,7 +22,7 @@ class Disk : public ALabel {
   std::string path_;
   std::string unit_;
 
-  float calc_specific_divisor(const std::string divisor);
+  float calc_specific_divisor(const std::string& divisor);
 };
 
 }  // namespace waybar::modules
diff --git a/include/modules/hyprland/windowcreationpayload.hpp b/include/modules/hyprland/windowcreationpayload.hpp
index 226a7c41..906be805 100644
--- a/include/modules/hyprland/windowcreationpayload.hpp
+++ b/include/modules/hyprland/windowcreationpayload.hpp
@@ -40,10 +40,11 @@ struct WindowRepr {
 
 class WindowCreationPayload {
  public:
-  WindowCreationPayload(std::string workspace_name, WindowAddress window_address,
+  WindowCreationPayload(const std::string& workspace_name, WindowAddress window_address,
                         WindowRepr window_repr);
-  WindowCreationPayload(std::string workspace_name, WindowAddress window_address,
-                        std::string window_class, std::string window_title, bool is_active);
+  WindowCreationPayload(const std::string& workspace_name, WindowAddress window_address,
+                        const std::string& window_class, const std::string& window_title,
+                        bool is_active);
   WindowCreationPayload(Json::Value const& client_data);
 
   int incrementTimeSpentUncreated();
diff --git a/include/modules/hyprland/workspaces.hpp b/include/modules/hyprland/workspaces.hpp
index 8bf88888..0cec3c1d 100644
--- a/include/modules/hyprland/workspaces.hpp
+++ b/include/modules/hyprland/workspaces.hpp
@@ -59,7 +59,7 @@ class Workspaces : public AModule, public EventHandler {
   enum class ActiveWindowPosition { NONE, FIRST, LAST };
   auto activeWindowPosition() const -> ActiveWindowPosition { return m_activeWindowPosition; }
 
-  std::string getRewrite(std::string window_class, std::string window_title);
+  std::string getRewrite(const std::string& window_class, const std::string& window_title);
   std::string& getWindowSeparator() { return m_formatWindowSeparator; }
   bool isWorkspaceIgnored(std::string const& workspace_name);
 
diff --git a/include/modules/mpd/mpd.hpp b/include/modules/mpd/mpd.hpp
index 32d526e9..9d81638e 100644
--- a/include/modules/mpd/mpd.hpp
+++ b/include/modules/mpd/mpd.hpp
@@ -44,7 +44,7 @@ class MPD : public ALabel {
   std::string getFilename() const;
   void setLabel();
   std::string getStateIcon() const;
-  std::string getOptionIcon(std::string optionName, bool activated) const;
+  std::string getOptionIcon(const std::string& optionName, bool activated) const;
 
   // GUI-side methods
   bool handlePlayPause(GdkEventButton* const&);
diff --git a/include/modules/sni/host.hpp b/include/modules/sni/host.hpp
index 6c62ac31..7248ad2f 100644
--- a/include/modules/sni/host.hpp
+++ b/include/modules/sni/host.hpp
@@ -30,7 +30,7 @@ class Host {
   static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
 
   std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
-  void addRegisteredItem(std::string service);
+  void addRegisteredItem(const std::string& service);
 
   std::vector<std::unique_ptr<Item>> items_;
   const std::string bus_name_;
diff --git a/include/modules/sway/bar.hpp b/include/modules/sway/bar.hpp
index fd48e5a3..381c6c37 100644
--- a/include/modules/sway/bar.hpp
+++ b/include/modules/sway/bar.hpp
@@ -37,7 +37,7 @@ class BarIpcClient {
   void onModeUpdate(bool visible_by_modifier);
   void onUrgencyUpdate(bool visible_by_urgency);
   void update();
-  bool isModuleEnabled(std::string name);
+  bool isModuleEnabled(const std::string& name);
 
   Bar& bar_;
   util::JsonParser parser_;
diff --git a/include/modules/sway/language.hpp b/include/modules/sway/language.hpp
index 91aa181d..470b9879 100644
--- a/include/modules/sway/language.hpp
+++ b/include/modules/sway/language.hpp
@@ -47,7 +47,7 @@ class Language : public ALabel, public sigc::trackable {
   void onEvent(const struct Ipc::ipc_response&);
   void onCmd(const struct Ipc::ipc_response&);
 
-  auto set_current_layout(std::string current_layout) -> void;
+  auto set_current_layout(const std::string& current_layout) -> void;
   auto init_layouts_map(const std::vector<std::string>& used_layouts) -> void;
 
   const static std::string XKB_LAYOUT_NAMES_KEY;
diff --git a/include/modules/sway/workspaces.hpp b/include/modules/sway/workspaces.hpp
index d8a9e18a..14528841 100644
--- a/include/modules/sway/workspaces.hpp
+++ b/include/modules/sway/workspaces.hpp
@@ -27,7 +27,7 @@ class Workspaces : public AModule, public sigc::trackable {
   static constexpr std::string_view persistent_workspace_switch_cmd_ =
       R"(workspace {} "{}"; move workspace to output "{}"; workspace {} "{}")";
 
-  static int convertWorkspaceNameToNum(std::string name);
+  static int convertWorkspaceNameToNum(const std::string& name);
   static int windowRewritePriorityFunction(std::string const& window_rule);
 
   void onCmd(const struct Ipc::ipc_response&);
@@ -40,7 +40,7 @@ class Workspaces : public AModule, public sigc::trackable {
   std::string getIcon(const std::string&, const Json::Value&);
   std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
   uint16_t getWorkspaceIndex(const std::string& name) const;
-  static std::string trimWorkspaceName(std::string);
+  static std::string trimWorkspaceName(const std::string&);
   bool handleScroll(GdkEventScroll* /*unused*/) override;
 
   const Bar& bar_;
diff --git a/include/util/SafeSignal.hpp b/include/util/SafeSignal.hpp
index 1e901792..afb0893e 100644
--- a/include/util/SafeSignal.hpp
+++ b/include/util/SafeSignal.hpp
@@ -3,10 +3,10 @@
 #include <glibmm/dispatcher.h>
 #include <sigc++/signal.h>
 
+#include <cstddef>
 #include <functional>
 #include <mutex>
 #include <queue>
-#include <cstddef>
 #include <thread>
 #include <tuple>
 #include <type_traits>
diff --git a/include/util/sleeper_thread.hpp b/include/util/sleeper_thread.hpp
index 966772a2..1f3a372d 100644
--- a/include/util/sleeper_thread.hpp
+++ b/include/util/sleeper_thread.hpp
@@ -72,8 +72,7 @@ class SleeperThread {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
     return condvar_.wait(lk, [this] {
-      return signal_.load(std::memory_order_relaxed) ||
-             !do_run_.load(std::memory_order_relaxed);
+      return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
     });
   }
 
@@ -87,8 +86,7 @@ class SleeperThread {
       wait_end = now + dur;
     }
     return condvar_.wait_until(lk, wait_end, [this] {
-      return signal_.load(std::memory_order_relaxed) ||
-             !do_run_.load(std::memory_order_relaxed);
+      return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
     });
   }
 
@@ -98,8 +96,7 @@ class SleeperThread {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
     return condvar_.wait_until(lk, time_point, [this] {
-      return signal_.load(std::memory_order_relaxed) ||
-             !do_run_.load(std::memory_order_relaxed);
+      return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
     });
   }
 
diff --git a/src/modules/disk.cpp b/src/modules/disk.cpp
index fd7ef817..462940b2 100644
--- a/src/modules/disk.cpp
+++ b/src/modules/disk.cpp
@@ -92,7 +92,7 @@ auto waybar::modules::Disk::update() -> void {
   ALabel::update();
 }
 
-float waybar::modules::Disk::calc_specific_divisor(std::string divisor) {
+float waybar::modules::Disk::calc_specific_divisor(const std::string& divisor) {
   if (divisor == "kB") {
     return 1000.0;
   } else if (divisor == "kiB") {
diff --git a/src/modules/hyprland/windowcreationpayload.cpp b/src/modules/hyprland/windowcreationpayload.cpp
index 61ea606f..5ace5b32 100644
--- a/src/modules/hyprland/windowcreationpayload.cpp
+++ b/src/modules/hyprland/windowcreationpayload.cpp
@@ -19,7 +19,7 @@ WindowCreationPayload::WindowCreationPayload(Json::Value const& client_data)
   clearWorkspaceName();
 }
 
-WindowCreationPayload::WindowCreationPayload(std::string workspace_name,
+WindowCreationPayload::WindowCreationPayload(const std::string& workspace_name,
                                              WindowAddress window_address, WindowRepr window_repr)
     : m_window(std::move(window_repr)),
       m_windowAddress(std::move(window_address)),
@@ -28,9 +28,10 @@ WindowCreationPayload::WindowCreationPayload(std::string workspace_name,
   clearWorkspaceName();
 }
 
-WindowCreationPayload::WindowCreationPayload(std::string workspace_name,
-                                             WindowAddress window_address, std::string window_class,
-                                             std::string window_title, bool is_active)
+WindowCreationPayload::WindowCreationPayload(const std::string& workspace_name,
+                                             WindowAddress window_address,
+                                             const std::string& window_class,
+                                             const std::string& window_title, bool is_active)
     : m_window(std::make_pair(std::move(window_class), std::move(window_title))),
       m_windowAddress(std::move(window_address)),
       m_workspaceName(std::move(workspace_name)),
diff --git a/src/modules/hyprland/workspaces.cpp b/src/modules/hyprland/workspaces.cpp
index 88b01223..dd891673 100644
--- a/src/modules/hyprland/workspaces.cpp
+++ b/src/modules/hyprland/workspaces.cpp
@@ -155,7 +155,8 @@ void Workspaces::extendOrphans(int workspaceId, Json::Value const& clientsJson)
   }
 }
 
-std::string Workspaces::getRewrite(std::string window_class, std::string window_title) {
+std::string Workspaces::getRewrite(const std::string& window_class,
+                                   const std::string& window_title) {
   std::string windowReprKey;
   if (windowRewriteConfigUsesTitle()) {
     windowReprKey = fmt::format("class<{}> title<{}>", window_class, window_title);
diff --git a/src/modules/inhibitor.cpp b/src/modules/inhibitor.cpp
index 170d0508..43c1f83e 100644
--- a/src/modules/inhibitor.cpp
+++ b/src/modules/inhibitor.cpp
@@ -85,7 +85,8 @@ auto getInhibitors(const Json::Value& config) -> std::string {
   if (config["what"].isArray()) {
     inhibitors = checkInhibitor(config["what"][0].asString());
     for (decltype(config["what"].size()) i = 1; i < config["what"].size(); ++i) {
-      inhibitors += ":" + checkInhibitor(config["what"][i].asString());
+      inhibitors.append(":");
+      inhibitors.append(checkInhibitor(config["what"][i].asString()));
     }
     return inhibitors;
   }
diff --git a/src/modules/mpd/mpd.cpp b/src/modules/mpd/mpd.cpp
index 1e28a58a..9874f458 100644
--- a/src/modules/mpd/mpd.cpp
+++ b/src/modules/mpd/mpd.cpp
@@ -239,7 +239,8 @@ std::string waybar::modules::MPD::getStateIcon() const {
   }
 }
 
-std::string waybar::modules::MPD::getOptionIcon(std::string optionName, bool activated) const {
+std::string waybar::modules::MPD::getOptionIcon(const std::string& optionName,
+                                                bool activated) const {
   if (!config_[optionName + "-icons"].isObject()) {
     return "";
   }
diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index 34dcc03c..868a06f2 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -321,6 +321,7 @@ auto waybar::modules::Network::update() -> void {
   } else if (addr_pref_ == ip_addr_pref::IPV6) {
     final_ipaddr_ = ipaddr6_;
   } else if (addr_pref_ == ip_addr_pref::IPV4_6) {
+    final_ipaddr_.reserve(ipaddr_.length() + ipaddr6_.length() + 1);
     final_ipaddr_ = ipaddr_;
     final_ipaddr_ += '\n';
     final_ipaddr_ += ipaddr6_;
diff --git a/src/modules/sni/host.cpp b/src/modules/sni/host.cpp
index 75501207..6bd1154a 100644
--- a/src/modules/sni/host.cpp
+++ b/src/modules/sni/host.cpp
@@ -132,7 +132,7 @@ std::tuple<std::string, std::string> Host::getBusNameAndObjectPath(const std::st
   return {service, "/StatusNotifierItem"};
 }
 
-void Host::addRegisteredItem(std::string service) {
+void Host::addRegisteredItem(const std::string& service) {
   std::string bus_name, object_path;
   std::tie(bus_name, object_path) = getBusNameAndObjectPath(service);
   auto it = std::find_if(items_.begin(), items_.end(), [&bus_name, &object_path](const auto& item) {
diff --git a/src/modules/sway/bar.cpp b/src/modules/sway/bar.cpp
index f28b0502..f374f1c1 100644
--- a/src/modules/sway/bar.cpp
+++ b/src/modules/sway/bar.cpp
@@ -60,7 +60,7 @@ BarIpcClient::BarIpcClient(waybar::Bar& bar) : bar_{bar} {
   });
 }
 
-bool BarIpcClient::isModuleEnabled(std::string name) {
+bool BarIpcClient::isModuleEnabled(const std::string& name) {
   for (const auto& section : {"modules-left", "modules-center", "modules-right"}) {
     if (const auto& modules = bar_.config.get(section, {}); modules.isArray()) {
       for (const auto& module : modules) {
diff --git a/src/modules/sway/language.cpp b/src/modules/sway/language.cpp
index f4cfa6c3..2e1103d3 100644
--- a/src/modules/sway/language.cpp
+++ b/src/modules/sway/language.cpp
@@ -124,7 +124,7 @@ auto Language::update() -> void {
   ALabel::update();
 }
 
-auto Language::set_current_layout(std::string current_layout) -> void {
+auto Language::set_current_layout(const std::string& current_layout) -> void {
   label_.get_style_context()->remove_class(layout_.short_name);
   layout_ = layouts_map_[current_layout];
   label_.get_style_context()->add_class(layout_.short_name);
diff --git a/src/modules/sway/window.cpp b/src/modules/sway/window.cpp
index 830a4120..2908b85c 100644
--- a/src/modules/sway/window.cpp
+++ b/src/modules/sway/window.cpp
@@ -184,9 +184,9 @@ std::tuple<std::string, std::string, std::string, std::string> getWindowInfo(
         continue;
       }
       if (!marks.empty()) {
-        marks += ',';
+        marks.append(",");
       }
-      marks += m.asString();
+      marks.append(m.asString());
     }
   }
   return {app_id, app_class, shell, marks};
diff --git a/src/modules/sway/workspaces.cpp b/src/modules/sway/workspaces.cpp
index e0255893..6abe5383 100644
--- a/src/modules/sway/workspaces.cpp
+++ b/src/modules/sway/workspaces.cpp
@@ -10,7 +10,7 @@ namespace waybar::modules::sway {
 
 // Helper function to assign a number to a workspace, just like sway. In fact
 // this is taken quite verbatim from `sway/ipc-json.c`.
-int Workspaces::convertWorkspaceNameToNum(std::string name) {
+int Workspaces::convertWorkspaceNameToNum(const std::string& name) {
   if (isdigit(name[0]) != 0) {
     errno = 0;
     char* endptr = nullptr;
@@ -487,7 +487,7 @@ std::string Workspaces::getCycleWorkspace(std::vector<Json::Value>::iterator it,
   return (*it)["name"].asString();
 }
 
-std::string Workspaces::trimWorkspaceName(std::string name) {
+std::string Workspaces::trimWorkspaceName(const std::string& name) {
   std::size_t found = name.find(':');
   if (found != std::string::npos) {
     return name.substr(found + 1);
diff --git a/src/modules/upower.cpp b/src/modules/upower.cpp
index 8202b718..d260ba83 100644
--- a/src/modules/upower.cpp
+++ b/src/modules/upower.cpp
@@ -95,7 +95,7 @@ UPower::~UPower() {
   removeDevices();
 }
 
-static const std::string getDeviceStatus(UpDeviceState& state) {
+static std::string_view getDeviceStatus(UpDeviceState& state) {
   switch (state) {
     case UP_DEVICE_STATE_CHARGING:
     case UP_DEVICE_STATE_PENDING_CHARGE:
@@ -112,7 +112,7 @@ static const std::string getDeviceStatus(UpDeviceState& state) {
   }
 }
 
-static const std::string getDeviceIcon(UpDeviceKind& kind) {
+static std::string_view getDeviceIcon(UpDeviceKind& kind) {
   switch (kind) {
     case UP_DEVICE_KIND_LINE_POWER:
       return "ac-adapter-symbolic";
@@ -212,7 +212,8 @@ auto UPower::update() -> void {
   // Remove last status if it exists
   if (!lastStatus_.empty() && box_.get_style_context()->has_class(lastStatus_))
     box_.get_style_context()->remove_class(lastStatus_);
-  if (!box_.get_style_context()->has_class(status)) box_.get_style_context()->add_class(status);
+  if (!box_.get_style_context()->has_class(std::string(status)))
+    box_.get_style_context()->add_class(std::string(status));
   lastStatus_ = status;
 
   if (devices_.size() == 0 && !upDeviceValid && hideIfEmpty_) {
diff --git a/test/utils/sleeper_thread.cpp b/test/utils/sleeper_thread.cpp
index 7a9a3ca1..9e1a1ef3 100644
--- a/test/utils/sleeper_thread.cpp
+++ b/test/utils/sleeper_thread.cpp
@@ -4,11 +4,12 @@
 #include <catch2/catch.hpp>
 #endif
 
-#include <chrono>
 #include <sys/wait.h>
-#include <thread>
 #include <unistd.h>
 
+#include <chrono>
+#include <thread>
+
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::util {

From e684e701df0515efd207b2f70ca766acc9770075 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 22:27:41 -0600
Subject: [PATCH 21/63] perf(sni): eliminate redundant g_memdup2 allocation for
 D-Bus pixbufs

Memory profiling via Valgrind Massif indicated that 10-20% of peak memory allocations within the SNI loop resulted from copying DBus image data payloads via g_memdup2 before modifying them from ARGB to RGBA.

This commit optimizes the pixel conversion by directly allocating the final array via g_malloc and running the ARGB->RGBA transposition in a single pass while copying from the read-only GVariant buffer, entirely eliminating the intermediate g_memdup stage.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/sni/item.cpp | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/modules/sni/item.cpp b/src/modules/sni/item.cpp
index d33765d2..7ce95faf 100644
--- a/src/modules/sni/item.cpp
+++ b/src/modules/sni/item.cpp
@@ -336,11 +336,20 @@ Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
           if (array != nullptr) {
             g_free(array);
           }
-#if GLIB_MAJOR_VERSION >= 2 && GLIB_MINOR_VERSION >= 68
-          array = static_cast<guchar*>(g_memdup2(data, size));
-#else
-          array = static_cast<guchar*>(g_memdup(data, size));
-#endif
+          // We must allocate our own array because the data from GVariant is read-only
+          // and we need to modify it to convert ARGB to RGBA.
+          array = static_cast<guchar*>(g_malloc(size));
+
+          // Copy and convert ARGB to RGBA in one pass to avoid g_memdup2 overhead
+          const guchar* src = static_cast<const guchar*>(data);
+          for (gsize i = 0; i < size; i += 4) {
+            guchar alpha = src[i];
+            array[i] = src[i + 1];
+            array[i + 1] = src[i + 2];
+            array[i + 2] = src[i + 3];
+            array[i + 3] = alpha;
+          }
+
           lwidth = width;
           lheight = height;
         }
@@ -349,14 +358,6 @@ Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
   }
   g_variant_iter_free(it);
   if (array != nullptr) {
-    /* argb to rgba */
-    for (uint32_t i = 0; i < 4U * lwidth * lheight; i += 4) {
-      guchar alpha = array[i];
-      array[i] = array[i + 1];
-      array[i + 1] = array[i + 2];
-      array[i + 2] = array[i + 3];
-      array[i + 3] = alpha;
-    }
     return Gdk::Pixbuf::create_from_data(array, Gdk::Colorspace::COLORSPACE_RGB, true, 8, lwidth,
                                          lheight, 4 * lwidth, &pixbuf_data_deleter);
   }

From 7d8be29f97b17061404c1ba01938b9481499e2be Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 22:36:55 -0600
Subject: [PATCH 22/63] perf(sni): eliminate icon theme rescanning from system
 tray hotpath

Valgrind Massif profiling revealed that invoking Gtk::IconTheme::rescan_if_needed() inside SNI updateImage() and getIconByName() loops caused considerable memory churn and potential filesystem stat overhead whenever a system tray app pushed a metadata update.

This commit removes the rescan polling from the SNI proxy callback pipeline and the DefaultGtkIconThemeWrapper, restricting icon theme caching to load boundaries.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/sni/item.cpp | 2 --
 src/util/gtk_icon.cpp    | 1 -
 2 files changed, 3 deletions(-)

diff --git a/src/modules/sni/item.cpp b/src/modules/sni/item.cpp
index 7ce95faf..1428bd8e 100644
--- a/src/modules/sni/item.cpp
+++ b/src/modules/sni/item.cpp
@@ -423,8 +423,6 @@ Glib::RefPtr<Gdk::Pixbuf> Item::getIconPixbuf() {
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Item::getIconByName(const std::string& name, int request_size) {
-  icon_theme->rescan_if_needed();
-
   if (!icon_theme_path.empty()) {
     auto icon_info = icon_theme->lookup_icon(name.c_str(), request_size,
                                              Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
diff --git a/src/util/gtk_icon.cpp b/src/util/gtk_icon.cpp
index 73f77284..1b2fca57 100644
--- a/src/util/gtk_icon.cpp
+++ b/src/util/gtk_icon.cpp
@@ -21,7 +21,6 @@ Glib::RefPtr<Gdk::Pixbuf> DefaultGtkIconThemeWrapper::load_icon(
   const std::lock_guard<std::mutex> lock(default_theme_mutex);
 
   auto default_theme = Gtk::IconTheme::get_default();
-  default_theme->rescan_if_needed();
 
   auto icon_info = default_theme->lookup_icon(name, tmp_size, flags);
 

From fe03dfaa3bb32622139a1a3b124d31af631e7837 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 22:40:14 -0600
Subject: [PATCH 23/63] perf(memory): eliminate deep copies in range-based for
 loops and lambdas

This commit addresses memory churn caused by implicit deep copies during traversal and allocation of complex structures:

- Replaced pass-by-value 'Json::Value' in std::ranges and range-based for loops with 'const auto&' or 'const Json::Value&' in Hyprland modules, preventing large JSON tree duplications on every update.

- Fixed implicit string and pair copies in UPower and CPU Frequency loops by converting 'auto' to 'const auto&' where possible.

- Added 'std::vector::reserve' calls before 'push_back' loops in MPRIS, Niri, and CFFI modules to prevent exponential vector reallocation during initialization.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/cffi.cpp                 |  1 +
 src/modules/cpu_frequency/linux.cpp  |  2 +-
 src/modules/hyprland/window.cpp      | 16 ++++++++--------
 src/modules/hyprland/windowcount.cpp |  4 ++--
 src/modules/hyprland/workspace.cpp   |  2 +-
 src/modules/hyprland/workspaces.cpp  |  6 +++---
 src/modules/mpris/mpris.cpp          |  1 +
 src/modules/niri/language.cpp        |  1 +
 8 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/src/modules/cffi.cpp b/src/modules/cffi.cpp
index 930c4d47..c3f1398f 100644
--- a/src/modules/cffi.cpp
+++ b/src/modules/cffi.cpp
@@ -71,6 +71,7 @@ CFFI::CFFI(const std::string& name, const std::string& id, const Json::Value& co
 
   // Prepare config_entries array
   std::vector<ffi::wbcffi_config_entry> config_entries;
+  config_entries.reserve(keys.size());
   for (size_t i = 0; i < keys.size(); i++) {
     config_entries.push_back({keys[i].c_str(), config_entries_stringstor[i].c_str()});
   }
diff --git a/src/modules/cpu_frequency/linux.cpp b/src/modules/cpu_frequency/linux.cpp
index 1f368789..83f06aa5 100644
--- a/src/modules/cpu_frequency/linux.cpp
+++ b/src/modules/cpu_frequency/linux.cpp
@@ -26,7 +26,7 @@ std::vector<float> waybar::modules::CpuFrequency::parseCpuFrequencies() {
     if (std::filesystem::exists(cpufreq_dir)) {
       std::vector<std::string> frequency_files = {"/cpuinfo_min_freq", "/cpuinfo_max_freq"};
       for (auto& p : std::filesystem::directory_iterator(cpufreq_dir)) {
-        for (auto freq_file : frequency_files) {
+        for (const auto& freq_file : frequency_files) {
           std::string freq_file_path = p.path().string() + freq_file;
           if (std::filesystem::exists(freq_file_path)) {
             std::string freq_value;
diff --git a/src/modules/hyprland/window.cpp b/src/modules/hyprland/window.cpp
index 1fddb45b..97d49eaf 100644
--- a/src/modules/hyprland/window.cpp
+++ b/src/modules/hyprland/window.cpp
@@ -124,7 +124,7 @@ auto Window::getActiveWorkspace(const std::string& monitorName) -> Workspace {
   const auto monitors = IPC::inst().getSocket1JsonReply("monitors");
   if (monitors.isArray()) {
     auto monitor = std::ranges::find_if(
-        monitors, [&](Json::Value monitor) { return monitor["name"] == monitorName; });
+        monitors, [&](const Json::Value& monitor) { return monitor["name"] == monitorName; });
     if (monitor == std::end(monitors)) {
       spdlog::warn("Monitor not found: {}", monitorName);
       return Workspace{
@@ -139,7 +139,7 @@ auto Window::getActiveWorkspace(const std::string& monitorName) -> Workspace {
     const auto workspaces = IPC::inst().getSocket1JsonReply("workspaces");
     if (workspaces.isArray()) {
       auto workspace = std::ranges::find_if(
-          workspaces, [&](Json::Value workspace) { return workspace["id"] == id; });
+          workspaces, [&](const Json::Value& workspace) { return workspace["id"] == id; });
       if (workspace == std::end(workspaces)) {
         spdlog::warn("No workspace with id {}", id);
         return Workspace{
@@ -190,7 +190,7 @@ void Window::queryActiveWorkspace() {
     const auto clients = m_ipc.getSocket1JsonReply("clients");
     if (clients.isArray()) {
       auto activeWindow = std::ranges::find_if(
-          clients, [&](Json::Value window) { return window["address"] == workspace_.last_window; });
+          clients, [&](const Json::Value& window) { return window["address"] == workspace_.last_window; });
 
       if (activeWindow == std::end(clients)) {
         focused_ = false;
@@ -200,19 +200,19 @@ void Window::queryActiveWorkspace() {
       windowData_ = WindowData::parse(*activeWindow);
       updateAppIconName(windowData_.class_name, windowData_.initial_class_name);
       std::vector<Json::Value> workspaceWindows;
-      std::ranges::copy_if(clients, std::back_inserter(workspaceWindows), [&](Json::Value window) {
+      std::ranges::copy_if(clients, std::back_inserter(workspaceWindows), [&](const Json::Value& window) {
         return window["workspace"]["id"] == workspace_.id && window["mapped"].asBool();
       });
-      swallowing_ = std::ranges::any_of(workspaceWindows, [&](Json::Value window) {
+      swallowing_ = std::ranges::any_of(workspaceWindows, [&](const Json::Value& window) {
         return !window["swallowing"].isNull() && window["swallowing"].asString() != "0x0";
       });
       std::vector<Json::Value> visibleWindows;
       std::ranges::copy_if(workspaceWindows, std::back_inserter(visibleWindows),
-                           [&](Json::Value window) { return !window["hidden"].asBool(); });
+                           [&](const Json::Value& window) { return !window["hidden"].asBool(); });
       solo_ = 1 == std::count_if(visibleWindows.begin(), visibleWindows.end(),
-                                 [&](Json::Value window) { return !window["floating"].asBool(); });
+                                 [&](const Json::Value& window) { return !window["floating"].asBool(); });
       allFloating_ = std::ranges::all_of(
-          visibleWindows, [&](Json::Value window) { return window["floating"].asBool(); });
+          visibleWindows, [&](const Json::Value& window) { return window["floating"].asBool(); });
       fullscreen_ = windowData_.fullscreen;
 
       // Fullscreen windows look like they are solo
diff --git a/src/modules/hyprland/windowcount.cpp b/src/modules/hyprland/windowcount.cpp
index ab573cca..5f5db80c 100644
--- a/src/modules/hyprland/windowcount.cpp
+++ b/src/modules/hyprland/windowcount.cpp
@@ -79,7 +79,7 @@ auto WindowCount::getActiveWorkspace(const std::string& monitorName) -> Workspac
   const auto monitors = m_ipc.getSocket1JsonReply("monitors");
   if (monitors.isArray()) {
     auto monitor = std::ranges::find_if(
-        monitors, [&](Json::Value monitor) { return monitor["name"] == monitorName; });
+        monitors, [&](const Json::Value& monitor) { return monitor["name"] == monitorName; });
     if (monitor == std::end(monitors)) {
       spdlog::warn("Monitor not found: {}", monitorName);
       return Workspace{
@@ -93,7 +93,7 @@ auto WindowCount::getActiveWorkspace(const std::string& monitorName) -> Workspac
     const auto workspaces = m_ipc.getSocket1JsonReply("workspaces");
     if (workspaces.isArray()) {
       auto workspace = std::ranges::find_if(
-          workspaces, [&](Json::Value workspace) { return workspace["id"] == id; });
+          workspaces, [&](const Json::Value& workspace) { return workspace["id"] == id; });
       if (workspace == std::end(workspaces)) {
         spdlog::warn("No workspace with id {}", id);
         return Workspace{
diff --git a/src/modules/hyprland/workspace.cpp b/src/modules/hyprland/workspace.cpp
index 87933ac0..21e7ef9b 100644
--- a/src/modules/hyprland/workspace.cpp
+++ b/src/modules/hyprland/workspace.cpp
@@ -96,7 +96,7 @@ bool Workspace::handleClicked(GdkEventButton* bt) const {
 
 void Workspace::initializeWindowMap(const Json::Value& clients_data) {
   m_windowMap.clear();
-  for (auto client : clients_data) {
+  for (const auto& client : clients_data) {
     if (client["workspace"]["id"].asInt() == id()) {
       insertWindow({client});
     }
diff --git a/src/modules/hyprland/workspaces.cpp b/src/modules/hyprland/workspaces.cpp
index dd891673..cbd14f90 100644
--- a/src/modules/hyprland/workspaces.cpp
+++ b/src/modules/hyprland/workspaces.cpp
@@ -197,7 +197,7 @@ void Workspaces::initializeWorkspaces() {
   auto const workspacesJson = m_ipc.getSocket1JsonReply("workspaces");
   auto const clientsJson = m_ipc.getSocket1JsonReply("clients");
 
-  for (Json::Value workspaceJson : workspacesJson) {
+  for (const auto& workspaceJson : workspacesJson) {
     std::string workspaceName = workspaceJson["name"].asString();
     if ((allOutputs() || m_bar.output->name == workspaceJson["monitor"].asString()) &&
         (!workspaceName.starts_with("special") || showSpecial()) &&
@@ -401,7 +401,7 @@ void Workspaces::onWorkspaceCreated(std::string const& payload, Json::Value cons
   auto const workspaceRules = m_ipc.getSocket1JsonReply("workspacerules");
   auto const workspacesJson = m_ipc.getSocket1JsonReply("workspaces");
 
-  for (Json::Value workspaceJson : workspacesJson) {
+  for (auto workspaceJson : workspacesJson) {
     const auto currentId = workspaceJson["id"].asInt();
     if (currentId == *workspaceId) {
       std::string workspaceName = workspaceJson["name"].asString();
@@ -1004,7 +1004,7 @@ void Workspaces::setUrgentWorkspace(std::string const& windowaddress) {
   const Json::Value clientsJson = m_ipc.getSocket1JsonReply("clients");
   int workspaceId = -1;
 
-  for (Json::Value clientJson : clientsJson) {
+  for (const auto& clientJson : clientsJson) {
     if (clientJson["address"].asString().ends_with(windowaddress)) {
       workspaceId = clientJson["workspace"]["id"].asInt();
       break;
diff --git a/src/modules/mpris/mpris.cpp b/src/modules/mpris/mpris.cpp
index 1bdd7df6..93f73690 100644
--- a/src/modules/mpris/mpris.cpp
+++ b/src/modules/mpris/mpris.cpp
@@ -109,6 +109,7 @@ Mpris::Mpris(const std::string& id, const Json::Value& config)
     player_ = config_["player"].asString();
   }
   if (config_["ignored-players"].isArray()) {
+    ignored_players_.reserve(config_["ignored-players"].size());
     for (const auto& item : config_["ignored-players"]) {
       if (item.isString()) {
         ignored_players_.push_back(item.asString());
diff --git a/src/modules/niri/language.cpp b/src/modules/niri/language.cpp
index 3359ef4c..14ca555f 100644
--- a/src/modules/niri/language.cpp
+++ b/src/modules/niri/language.cpp
@@ -32,6 +32,7 @@ void Language::updateFromIPC() {
   auto ipcLock = gIPC->lockData();
 
   layouts_.clear();
+  layouts_.reserve(gIPC->keyboardLayoutNames().size());
   for (const auto& fullName : gIPC->keyboardLayoutNames()) layouts_.push_back(getLayout(fullName));
 
   current_idx_ = gIPC->keyboardLayoutCurrent();

From c5449bd361bed8be9875c1322fd0d693ba975cdd Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Mon, 2 Mar 2026 23:12:54 -0600
Subject: [PATCH 24/63] fix(network): log new address only when state changes

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/network.cpp | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index e0866011..a25024e8 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -634,18 +634,31 @@ int waybar::modules::Network::handleEvents(struct nl_msg* msg, void* data) {
           case IFA_LOCAL:
             char ipaddr[INET6_ADDRSTRLEN];
             if (!is_del_event) {
+              bool addr_changed = false;
+              std::string changed_ipaddr;
+              int changed_cidr = 0;
               if ((net->addr_pref_ == ip_addr_pref::IPV4 ||
                    net->addr_pref_ == ip_addr_pref::IPV4_6) &&
                   net->cidr_ == 0 && ifa->ifa_family == AF_INET) {
-                net->ipaddr_ =
-                    inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr));
-                net->cidr_ = ifa->ifa_prefixlen;
+                if (inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr)) !=
+                    nullptr) {
+                  net->ipaddr_ = ipaddr;
+                  net->cidr_ = ifa->ifa_prefixlen;
+                  addr_changed = true;
+                  changed_ipaddr = net->ipaddr_;
+                  changed_cidr = net->cidr_;
+                }
               } else if ((net->addr_pref_ == ip_addr_pref::IPV6 ||
                           net->addr_pref_ == ip_addr_pref::IPV4_6) &&
                          net->cidr6_ == 0 && ifa->ifa_family == AF_INET6) {
-                net->ipaddr6_ =
-                    inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr));
-                net->cidr6_ = ifa->ifa_prefixlen;
+                if (inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr)) !=
+                    nullptr) {
+                  net->ipaddr6_ = ipaddr;
+                  net->cidr6_ = ifa->ifa_prefixlen;
+                  addr_changed = true;
+                  changed_ipaddr = net->ipaddr6_;
+                  changed_cidr = net->cidr6_;
+                }
               }
 
               switch (ifa->ifa_family) {
@@ -665,7 +678,10 @@ int waybar::modules::Network::handleEvents(struct nl_msg* msg, void* data) {
                   net->netmask6_ = inet_ntop(ifa->ifa_family, &netmask6, ipaddr, sizeof(ipaddr));
                 }
               }
-              spdlog::debug("network: {}, new addr {}/{}", net->ifname_, net->ipaddr_, net->cidr_);
+              if (addr_changed) {
+                spdlog::debug("network: {}, new addr {}/{}", net->ifname_, changed_ipaddr,
+                              changed_cidr);
+              }
             } else {
               net->ipaddr_.clear();
               net->ipaddr6_.clear();

From a97e8dad7cc739abf27a1562e9270000ac4124f1 Mon Sep 17 00:00:00 2001
From: Alison <alisonburgess@proton.me>
Date: Mon, 2 Mar 2026 23:40:15 -0800
Subject: [PATCH 25/63] Revert "Fix tooltip sync issue by removing conditional
 checks"

This reverts commit 2b29c9a5d6e353ce6d6686be2d51a6240c0778bf.
---
 src/modules/custom.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/modules/custom.cpp b/src/modules/custom.cpp
index e2b705da..ff897fef 100644
--- a/src/modules/custom.cpp
+++ b/src/modules/custom.cpp
@@ -188,9 +188,13 @@ auto waybar::modules::Custom::update() -> void {
                                   fmt::arg("percentage", percentage_));
             label_.set_tooltip_markup(tooltip);
           } else if (text_ == tooltip_) {
-            label_.set_tooltip_markup(str);
+            if (label_.get_tooltip_markup() != str) {
+              label_.set_tooltip_markup(str);
+            }
           } else {
-            label_.set_tooltip_markup(tooltip_);
+            if (label_.get_tooltip_markup() != tooltip_) {
+              label_.set_tooltip_markup(tooltip_);
+            }
           }
         }
         auto style = label_.get_style_context();

From 3eb2c7e8f43b25387e68b9e320321edf274840ee Mon Sep 17 00:00:00 2001
From: Alison <alisonburgess@proton.me>
Date: Mon, 2 Mar 2026 23:49:22 -0800
Subject: [PATCH 26/63] sync tooltip updates without resetting hover state

---
 include/modules/custom.hpp |  1 +
 src/modules/custom.cpp     | 24 +++++++++++++-----------
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/include/modules/custom.hpp b/include/modules/custom.hpp
index 6c17c6e4..a345a33b 100644
--- a/include/modules/custom.hpp
+++ b/include/modules/custom.hpp
@@ -35,6 +35,7 @@ class Custom : public ALabel {
   std::string id_;
   std::string alt_;
   std::string tooltip_;
+  std::string last_tooltip_markup_;
   const bool tooltip_format_enabled_;
   std::vector<std::string> class_;
   int percentage_;
diff --git a/src/modules/custom.cpp b/src/modules/custom.cpp
index ff897fef..93956614 100644
--- a/src/modules/custom.cpp
+++ b/src/modules/custom.cpp
@@ -1,6 +1,7 @@
 #include "modules/custom.hpp"
 
 #include <spdlog/spdlog.h>
+#include <utility>
 
 #include "util/scope_guard.hpp"
 
@@ -180,21 +181,22 @@ auto waybar::modules::Custom::update() -> void {
       } else {
         label_.set_markup(str);
         if (tooltipEnabled()) {
+          std::string tooltip_markup;
           if (tooltip_format_enabled_) {
             auto tooltip = config_["tooltip-format"].asString();
-            tooltip = fmt::format(fmt::runtime(tooltip), fmt::arg("text", text_),
-                                  fmt::arg("tooltip", tooltip_), fmt::arg("alt", alt_),
-                                  fmt::arg("icon", getIcon(percentage_, alt_)),
-                                  fmt::arg("percentage", percentage_));
-            label_.set_tooltip_markup(tooltip);
+            tooltip_markup = fmt::format(fmt::runtime(tooltip), fmt::arg("text", text_),
+                                         fmt::arg("tooltip", tooltip_), fmt::arg("alt", alt_),
+                                         fmt::arg("icon", getIcon(percentage_, alt_)),
+                                         fmt::arg("percentage", percentage_));
           } else if (text_ == tooltip_) {
-            if (label_.get_tooltip_markup() != str) {
-              label_.set_tooltip_markup(str);
-            }
+            tooltip_markup = str;
           } else {
-            if (label_.get_tooltip_markup() != tooltip_) {
-              label_.set_tooltip_markup(tooltip_);
-            }
+            tooltip_markup = tooltip_;
+          }
+
+          if (last_tooltip_markup_ != tooltip_markup) {
+            label_.set_tooltip_markup(tooltip_markup);
+            last_tooltip_markup_ = std::move(tooltip_markup);
           }
         }
         auto style = label_.get_style_context();

From a81621863790ce42cff243b215a01c229cef9142 Mon Sep 17 00:00:00 2001
From: Neale Swinnerton <neale@sw1nn.com>
Date: Tue, 3 Mar 2026 16:02:04 +0000
Subject: [PATCH 27/63] fix(mpris): disconnect GLib signals before destroying
 objects

Waybar SEGVs in Glib::DispatchNotifier::pipe_io_handler when the MPRIS
module is enabled. The crash is intermittent because it requires a race
between signal emission and object destruction: a playerctl GLib signal
callback (e.g. onPlayerPlay) calls dp.emit(), which writes a pointer to
the Dispatcher into an internal pipe. If the Mpris object is destroyed
before the GLib main loop reads that pipe entry, pipe_io_handler
dereferences a dangling pointer. This typically occurs when a media
player appears or vanishes on D-Bus (browser closing, player quitting)
or during waybar shutdown/config reload.

The root cause is that ~Mpris() calls g_object_unref() on the manager
and player GObjects without first disconnecting the signal handlers that
hold raw `this` pointers. If playerctl holds additional references to
these GObjects, they survive the unref and can still fire signals
targeting the already-destroyed Mpris instance.

Adopt the same cleanup pattern used by the Wireplumber module: call
g_signal_handlers_disconnect_by_data() to sever all signal connections
referencing `this` before releasing the GObjects with g_clear_object().
This guarantees no callbacks can enqueue stale Dispatcher notifications
after teardown begins.

Additionally:
- Clean up old player in onPlayerNameAppeared before replacing it,
  fixing a GObject leak and accumulation of dangling signal connections
- Remove duplicate onPlayerStop signal registration (copy-paste bug)
---
 src/modules/mpris/mpris.cpp | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/modules/mpris/mpris.cpp b/src/modules/mpris/mpris.cpp
index 1bdd7df6..5771a5ba 100644
--- a/src/modules/mpris/mpris.cpp
+++ b/src/modules/mpris/mpris.cpp
@@ -161,8 +161,7 @@ Mpris::Mpris(const std::string& id, const Json::Value& config)
   if (player) {
     g_object_connect(player, "signal::play", G_CALLBACK(onPlayerPlay), this, "signal::pause",
                      G_CALLBACK(onPlayerPause), this, "signal::stop", G_CALLBACK(onPlayerStop),
-                     this, "signal::stop", G_CALLBACK(onPlayerStop), this, "signal::metadata",
-                     G_CALLBACK(onPlayerMetadata), this, NULL);
+                     this, "signal::metadata", G_CALLBACK(onPlayerMetadata), this, NULL);
   }
 
   // allow setting an interval count that triggers periodic refreshes
@@ -178,9 +177,17 @@ Mpris::Mpris(const std::string& id, const Json::Value& config)
 }
 
 Mpris::~Mpris() {
-  if (last_active_player_ && last_active_player_ != player) g_object_unref(last_active_player_);
-  if (manager != nullptr) g_object_unref(manager);
-  if (player != nullptr) g_object_unref(player);
+  if (manager != nullptr) {
+    g_signal_handlers_disconnect_by_data(manager, this);
+  }
+  if (player != nullptr) {
+    g_signal_handlers_disconnect_by_data(player, this);
+  }
+  if (last_active_player_ != nullptr && last_active_player_ != player) {
+    g_object_unref(last_active_player_);
+  }
+  g_clear_object(&manager);
+  g_clear_object(&player);
 }
 
 auto Mpris::getIconFromJson(const Json::Value& icons, const std::string& key) -> std::string {
@@ -411,11 +418,14 @@ auto Mpris::onPlayerNameAppeared(PlayerctlPlayerManager* manager, PlayerctlPlaye
     return;
   }
 
+  if (mpris->player != nullptr) {
+    g_signal_handlers_disconnect_by_data(mpris->player, mpris);
+    g_clear_object(&mpris->player);
+  }
   mpris->player = playerctl_player_new_from_name(player_name, nullptr);
   g_object_connect(mpris->player, "signal::play", G_CALLBACK(onPlayerPlay), mpris, "signal::pause",
                    G_CALLBACK(onPlayerPause), mpris, "signal::stop", G_CALLBACK(onPlayerStop),
-                   mpris, "signal::stop", G_CALLBACK(onPlayerStop), mpris, "signal::metadata",
-                   G_CALLBACK(onPlayerMetadata), mpris, NULL);
+                   mpris, "signal::metadata", G_CALLBACK(onPlayerMetadata), mpris, NULL);
 
   mpris->dp.emit();
 }

From f48fce57dc6f40d8b3992041a715776fe6072dd1 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Fri, 6 Mar 2026 18:38:21 -0600
Subject: [PATCH 28/63] fix(menu): keep popup menus alive after builder
 teardown

The popup menu was retrieved from GtkBuilder and stored in menu_, but the builder was unref'd immediately after construction. That left the later popup path operating on a builder-owned GtkMenu whose lifetime was no longer guaranteed, which matches the GTK_IS_WIDGET and GTK_IS_MENU assertions from the regression report.

Take an owned reference to the built menu and release it in AModule teardown so popup menus stay valid without extending the lifetime of the whole builder.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/ALabel.cpp  | 2 ++
 src/AModule.cpp | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/src/ALabel.cpp b/src/ALabel.cpp
index fe87e098..795f87f1 100644
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@@ -100,6 +100,8 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
         g_object_unref(builder);
         throw std::runtime_error("Failed to get 'menu' object from GtkBuilder");
       }
+      // Keep the menu alive after dropping the transient GtkBuilder.
+      g_object_ref(menu_);
       submenus_ = std::map<std::string, GtkMenuItem*>();
       menuActionsMap_ = std::map<std::string, std::string>();
 
diff --git a/src/AModule.cpp b/src/AModule.cpp
index 5f3a187a..a5ba69d3 100644
--- a/src/AModule.cpp
+++ b/src/AModule.cpp
@@ -88,6 +88,10 @@ AModule::~AModule() {
       killpg(pid, SIGTERM);
     }
   }
+  if (menu_ != nullptr) {
+    g_object_unref(menu_);
+    menu_ = nullptr;
+  }
 }
 
 auto AModule::update() -> void {

From 790101f824513a6b48396fd956dd3a9dfae5ad4b Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Fri, 6 Mar 2026 18:49:02 -0600
Subject: [PATCH 29/63] chore: format

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/sway/ipc/client.hpp |  2 +-
 src/modules/custom.cpp              |  1 +
 src/modules/hyprland/window.cpp     | 17 ++++++++++-------
 src/modules/niri/backend.cpp        |  2 +-
 test/utils/command.cpp              |  5 +++--
 5 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/include/modules/sway/ipc/client.hpp b/include/modules/sway/ipc/client.hpp
index eb0f32f9..f6eb7c40 100644
--- a/include/modules/sway/ipc/client.hpp
+++ b/include/modules/sway/ipc/client.hpp
@@ -13,8 +13,8 @@
 
 #include "ipc.hpp"
 #include "util/SafeSignal.hpp"
-#include "util/sleeper_thread.hpp"
 #include "util/scoped_fd.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
 
diff --git a/src/modules/custom.cpp b/src/modules/custom.cpp
index 93956614..28def8c9 100644
--- a/src/modules/custom.cpp
+++ b/src/modules/custom.cpp
@@ -1,6 +1,7 @@
 #include "modules/custom.hpp"
 
 #include <spdlog/spdlog.h>
+
 #include <utility>
 
 #include "util/scope_guard.hpp"
diff --git a/src/modules/hyprland/window.cpp b/src/modules/hyprland/window.cpp
index 97d49eaf..a67e81ac 100644
--- a/src/modules/hyprland/window.cpp
+++ b/src/modules/hyprland/window.cpp
@@ -189,8 +189,9 @@ void Window::queryActiveWorkspace() {
   if (workspace_.windows > 0) {
     const auto clients = m_ipc.getSocket1JsonReply("clients");
     if (clients.isArray()) {
-      auto activeWindow = std::ranges::find_if(
-          clients, [&](const Json::Value& window) { return window["address"] == workspace_.last_window; });
+      auto activeWindow = std::ranges::find_if(clients, [&](const Json::Value& window) {
+        return window["address"] == workspace_.last_window;
+      });
 
       if (activeWindow == std::end(clients)) {
         focused_ = false;
@@ -200,17 +201,19 @@ void Window::queryActiveWorkspace() {
       windowData_ = WindowData::parse(*activeWindow);
       updateAppIconName(windowData_.class_name, windowData_.initial_class_name);
       std::vector<Json::Value> workspaceWindows;
-      std::ranges::copy_if(clients, std::back_inserter(workspaceWindows), [&](const Json::Value& window) {
-        return window["workspace"]["id"] == workspace_.id && window["mapped"].asBool();
-      });
+      std::ranges::copy_if(
+          clients, std::back_inserter(workspaceWindows), [&](const Json::Value& window) {
+            return window["workspace"]["id"] == workspace_.id && window["mapped"].asBool();
+          });
       swallowing_ = std::ranges::any_of(workspaceWindows, [&](const Json::Value& window) {
         return !window["swallowing"].isNull() && window["swallowing"].asString() != "0x0";
       });
       std::vector<Json::Value> visibleWindows;
       std::ranges::copy_if(workspaceWindows, std::back_inserter(visibleWindows),
                            [&](const Json::Value& window) { return !window["hidden"].asBool(); });
-      solo_ = 1 == std::count_if(visibleWindows.begin(), visibleWindows.end(),
-                                 [&](const Json::Value& window) { return !window["floating"].asBool(); });
+      solo_ = 1 == std::count_if(
+                       visibleWindows.begin(), visibleWindows.end(),
+                       [&](const Json::Value& window) { return !window["floating"].asBool(); });
       allFloating_ = std::ranges::all_of(
           visibleWindows, [&](const Json::Value& window) { return window["floating"].asBool(); });
       fullscreen_ = windowData_.fullscreen;
diff --git a/src/modules/niri/backend.cpp b/src/modules/niri/backend.cpp
index c23aaa47..de3f8a9a 100644
--- a/src/modules/niri/backend.cpp
+++ b/src/modules/niri/backend.cpp
@@ -13,11 +13,11 @@
 #include <string>
 #include <thread>
 
-#include "util/scoped_fd.hpp"
 #include "giomm/datainputstream.h"
 #include "giomm/dataoutputstream.h"
 #include "giomm/unixinputstream.h"
 #include "giomm/unixoutputstream.h"
+#include "util/scoped_fd.hpp"
 
 namespace waybar::modules::niri {
 
diff --git a/test/utils/command.cpp b/test/utils/command.cpp
index 2ccb3383..053a2b77 100644
--- a/test/utils/command.cpp
+++ b/test/utils/command.cpp
@@ -4,11 +4,12 @@
 #include <catch2/catch.hpp>
 #endif
 
+#include <sys/wait.h>
+#include <unistd.h>
+
 #include <cerrno>
 #include <list>
 #include <mutex>
-#include <sys/wait.h>
-#include <unistd.h>
 
 std::mutex reap_mtx;
 std::list<pid_t> reap;

From 0a35b86e2088360d3c27e46a4e61e97ef428eb51 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Fri, 6 Mar 2026 18:33:12 -0600
Subject: [PATCH 30/63] fix(hyprland/ipc): honor the requested instance
 signature

The Hyprland IPC helper cached the socket folder with the first instance
signature already appended, so later calls ignored their instanceSig argument
and always reused the first path. That made the helper violate its own API even
though most real Waybar sessions only talk to a single Hyprland instance.

Cache only the base socket directory and append the requested signature per
lookup. This fixes correctness for tests, nested or debug multi-instance
setups, and future code that needs to resolve a different signature, without
claiming support for one Waybar process managing multiple Hyprland sessions.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/hyprland/backend.cpp | 70 +++++++++++++++++++-------------
 test/hyprland/backend.cpp        | 18 ++++++++
 2 files changed, 60 insertions(+), 28 deletions(-)

diff --git a/src/modules/hyprland/backend.cpp b/src/modules/hyprland/backend.cpp
index 0f02b919..d0371202 100644
--- a/src/modules/hyprland/backend.cpp
+++ b/src/modules/hyprland/backend.cpp
@@ -25,27 +25,23 @@ std::filesystem::path IPC::getSocketFolder(const char* instanceSig) {
   static std::mutex folderMutex;
   std::unique_lock lock(folderMutex);
 
-  // socket path, specified by EventManager of Hyprland
-  if (!socketFolder_.empty()) {
-    return socketFolder_;
+  if (socketFolder_.empty()) {
+    const char* xdgRuntimeDirEnv = std::getenv("XDG_RUNTIME_DIR");
+    std::filesystem::path xdgRuntimeDir;
+    // Only set path if env variable is set
+    if (xdgRuntimeDirEnv != nullptr) {
+      xdgRuntimeDir = std::filesystem::path(xdgRuntimeDirEnv);
+    }
+
+    if (!xdgRuntimeDir.empty() && std::filesystem::exists(xdgRuntimeDir / "hypr")) {
+      socketFolder_ = xdgRuntimeDir / "hypr";
+    } else {
+      spdlog::warn("$XDG_RUNTIME_DIR/hypr does not exist, falling back to /tmp/hypr");
+      socketFolder_ = std::filesystem::path("/tmp") / "hypr";
+    }
   }
 
-  const char* xdgRuntimeDirEnv = std::getenv("XDG_RUNTIME_DIR");
-  std::filesystem::path xdgRuntimeDir;
-  // Only set path if env variable is set
-  if (xdgRuntimeDirEnv != nullptr) {
-    xdgRuntimeDir = std::filesystem::path(xdgRuntimeDirEnv);
-  }
-
-  if (!xdgRuntimeDir.empty() && std::filesystem::exists(xdgRuntimeDir / "hypr")) {
-    socketFolder_ = xdgRuntimeDir / "hypr";
-  } else {
-    spdlog::warn("$XDG_RUNTIME_DIR/hypr does not exist, falling back to /tmp/hypr");
-    socketFolder_ = std::filesystem::path("/tmp") / "hypr";
-  }
-
-  socketFolder_ = socketFolder_ / instanceSig;
-  return socketFolder_;
+  return socketFolder_ / instanceSig;
 }
 
 IPC::IPC() {
@@ -91,7 +87,7 @@ void IPC::socketListener() {
 
   spdlog::info("Hyprland IPC starting");
 
-  struct sockaddr_un addr;
+  struct sockaddr_un addr = {};
   const int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
 
   if (socketfd == -1) {
@@ -102,10 +98,13 @@ void IPC::socketListener() {
   addr.sun_family = AF_UNIX;
 
   auto socketPath = IPC::getSocketFolder(his) / ".socket2.sock";
+  if (socketPath.native().size() >= sizeof(addr.sun_path)) {
+    spdlog::error("Hyprland IPC: Socket path is too long: {}", socketPath.string());
+    close(socketfd);
+    return;
+  }
   strncpy(addr.sun_path, socketPath.c_str(), sizeof(addr.sun_path) - 1);
 
-  addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
-
   int l = sizeof(struct sockaddr_un);
 
   if (connect(socketfd, (struct sockaddr*)&addr, l) == -1) {
@@ -233,8 +232,10 @@ std::string IPC::getSocket1Reply(const std::string& rq) {
   std::string socketPath = IPC::getSocketFolder(instanceSig) / ".socket.sock";
 
   // Use snprintf to copy the socketPath string into serverAddress.sun_path
-  if (snprintf(serverAddress.sun_path, sizeof(serverAddress.sun_path), "%s", socketPath.c_str()) <
-      0) {
+  const auto socketPathLength =
+      snprintf(serverAddress.sun_path, sizeof(serverAddress.sun_path), "%s", socketPath.c_str());
+  if (socketPathLength < 0 ||
+      socketPathLength >= static_cast<int>(sizeof(serverAddress.sun_path))) {
     throw std::runtime_error("Hyprland IPC: Couldn't copy socket path (6)");
   }
 
@@ -243,15 +244,28 @@ std::string IPC::getSocket1Reply(const std::string& rq) {
     throw std::runtime_error("Hyprland IPC: Couldn't connect to " + socketPath + ". (3)");
   }
 
-  auto sizeWritten = write(serverSocket, rq.c_str(), rq.length());
+  std::size_t totalWritten = 0;
+  while (totalWritten < rq.length()) {
+    const auto sizeWritten =
+        write(serverSocket, rq.c_str() + totalWritten, rq.length() - totalWritten);
 
-  if (sizeWritten < 0) {
-    spdlog::error("Hyprland IPC: Couldn't write (4)");
-    return "";
+    if (sizeWritten < 0) {
+      if (errno == EINTR) {
+        continue;
+      }
+      spdlog::error("Hyprland IPC: Couldn't write (4)");
+      return "";
+    }
+    if (sizeWritten == 0) {
+      spdlog::error("Hyprland IPC: Socket write made no progress");
+      return "";
+    }
+    totalWritten += static_cast<std::size_t>(sizeWritten);
   }
 
   std::array<char, 8192> buffer = {0};
   std::string response;
+  ssize_t sizeWritten = 0;
 
   do {
     sizeWritten = read(serverSocket, buffer.data(), 8192);
diff --git a/test/hyprland/backend.cpp b/test/hyprland/backend.cpp
index cc7295ec..ccc2da65 100644
--- a/test/hyprland/backend.cpp
+++ b/test/hyprland/backend.cpp
@@ -86,6 +86,24 @@ TEST_CASE("XDGRuntimeDirExistsNoHyprDir", "[getSocketFolder]") {
   fs::remove_all(tempDir, ec);
 }
 
+TEST_CASE("Socket folder is resolved per instance signature", "[getSocketFolder]") {
+  const fs::path tempDir = fs::temp_directory_path() / "hypr_test/run/user/1000";
+  std::error_code ec;
+  fs::remove_all(tempDir, ec);
+  fs::create_directories(tempDir / "hypr");
+  setenv("XDG_RUNTIME_DIR", tempDir.c_str(), 1);
+  IPCTestHelper::resetSocketFolder();
+
+  const auto firstPath = hyprland::IPC::getSocketFolder("instance_a");
+  const auto secondPath = hyprland::IPC::getSocketFolder("instance_b");
+
+  REQUIRE(firstPath == tempDir / "hypr" / "instance_a");
+  REQUIRE(secondPath == tempDir / "hypr" / "instance_b");
+  REQUIRE(firstPath != secondPath);
+
+  fs::remove_all(tempDir, ec);
+}
+
 TEST_CASE("getSocket1Reply throws on no socket", "[getSocket1Reply]") {
   unsetenv("HYPRLAND_INSTANCE_SIGNATURE");
   IPCTestHelper::resetSocketFolder();

From b1a87f943c4da2cc6ab2fef700f64497db7fc205 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Fri, 6 Mar 2026 18:33:14 -0600
Subject: [PATCH 31/63] fix(hyprland/window): avoid stale state during IPC
 refresh

The window module re-entered the same shared_mutex while refreshing IPC state:
update() took the lock and then called queryActiveWorkspace(), which tried to
lock it again. That is undefined behavior for std::shared_mutex and could
manifest as a deadlock.

Remove the recursive lock path and reset the derived window state before each
IPC refresh. That keeps solo/floating/swallowing/fullscreen classes from
sticking around when the client lookup fails or a workspace becomes empty.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/hyprland/window.hpp |  22 +++---
 src/modules/hyprland/window.cpp     | 100 ++++++++++++++--------------
 2 files changed, 60 insertions(+), 62 deletions(-)

diff --git a/include/modules/hyprland/window.hpp b/include/modules/hyprland/window.hpp
index 2be64594..9725d33a 100644
--- a/include/modules/hyprland/window.hpp
+++ b/include/modules/hyprland/window.hpp
@@ -20,8 +20,8 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
 
  private:
   struct Workspace {
-    int id;
-    int windows;
+    int id = 0;
+    int windows = 0;
     std::string last_window;
     std::string last_window_title;
 
@@ -29,14 +29,14 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
   };
 
   struct WindowData {
-    bool floating;
+    bool floating = false;
     int monitor = -1;
     std::string class_name;
     std::string initial_class_name;
     std::string title;
     std::string initial_title;
-    bool fullscreen;
-    bool grouped;
+    bool fullscreen = false;
+    bool grouped = false;
 
     static auto parse(const Json::Value&) -> WindowData;
   };
@@ -47,7 +47,7 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
   void queryActiveWorkspace();
   void setClass(const std::string&, bool enable);
 
-  bool separateOutputs_;
+  bool separateOutputs_ = false;
   std::mutex mutex_;
   const Bar& bar_;
   util::JsonParser parser_;
@@ -55,11 +55,11 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
   Workspace workspace_;
   std::string soloClass_;
   std::string lastSoloClass_;
-  bool solo_;
-  bool allFloating_;
-  bool swallowing_;
-  bool fullscreen_;
-  bool focused_;
+  bool solo_ = false;
+  bool allFloating_ = false;
+  bool swallowing_ = false;
+  bool fullscreen_ = false;
+  bool focused_ = false;
 
   IPC& m_ipc;
 };
diff --git a/src/modules/hyprland/window.cpp b/src/modules/hyprland/window.cpp
index a67e81ac..d3fe6edf 100644
--- a/src/modules/hyprland/window.cpp
+++ b/src/modules/hyprland/window.cpp
@@ -32,7 +32,6 @@ Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
 
   windowIpcUniqueLock.unlock();
 
-  queryActiveWorkspace();
   update();
   dp.emit();
 }
@@ -177,66 +176,65 @@ auto Window::WindowData::parse(const Json::Value& value) -> Window::WindowData {
 }
 
 void Window::queryActiveWorkspace() {
-  std::shared_lock<std::shared_mutex> windowIpcShareLock(windowIpcSmtx);
-
   if (separateOutputs_) {
     workspace_ = getActiveWorkspace(this->bar_.output->name);
   } else {
     workspace_ = getActiveWorkspace();
   }
 
+  focused_ = false;
+  windowData_ = WindowData{};
+  allFloating_ = false;
+  swallowing_ = false;
+  fullscreen_ = false;
+  solo_ = false;
+  soloClass_.clear();
+
+  if (workspace_.windows <= 0) {
+    return;
+  }
+
+  const auto clients = m_ipc.getSocket1JsonReply("clients");
+  if (!clients.isArray()) {
+    return;
+  }
+
+  auto activeWindow = std::ranges::find_if(clients, [&](const Json::Value& window) {
+    return window["address"] == workspace_.last_window;
+  });
+
+  if (activeWindow == std::end(clients)) {
+    return;
+  }
+
   focused_ = true;
-  if (workspace_.windows > 0) {
-    const auto clients = m_ipc.getSocket1JsonReply("clients");
-    if (clients.isArray()) {
-      auto activeWindow = std::ranges::find_if(clients, [&](const Json::Value& window) {
-        return window["address"] == workspace_.last_window;
+  windowData_ = WindowData::parse(*activeWindow);
+  updateAppIconName(windowData_.class_name, windowData_.initial_class_name);
+  std::vector<Json::Value> workspaceWindows;
+  std::ranges::copy_if(
+      clients, std::back_inserter(workspaceWindows), [&](const Json::Value& window) {
+        return window["workspace"]["id"] == workspace_.id && window["mapped"].asBool();
       });
+  swallowing_ = std::ranges::any_of(workspaceWindows, [&](const Json::Value& window) {
+    return !window["swallowing"].isNull() && window["swallowing"].asString() != "0x0";
+  });
+  std::vector<Json::Value> visibleWindows;
+  std::ranges::copy_if(workspaceWindows, std::back_inserter(visibleWindows),
+                       [&](const Json::Value& window) { return !window["hidden"].asBool(); });
+  solo_ = 1 == std::count_if(
+                   visibleWindows.begin(), visibleWindows.end(),
+                   [&](const Json::Value& window) { return !window["floating"].asBool(); });
+  allFloating_ = std::ranges::all_of(
+      visibleWindows, [&](const Json::Value& window) { return window["floating"].asBool(); });
+  fullscreen_ = windowData_.fullscreen;
 
-      if (activeWindow == std::end(clients)) {
-        focused_ = false;
-        return;
-      }
+  // Fullscreen windows look like they are solo
+  if (fullscreen_) {
+    solo_ = true;
+  }
 
-      windowData_ = WindowData::parse(*activeWindow);
-      updateAppIconName(windowData_.class_name, windowData_.initial_class_name);
-      std::vector<Json::Value> workspaceWindows;
-      std::ranges::copy_if(
-          clients, std::back_inserter(workspaceWindows), [&](const Json::Value& window) {
-            return window["workspace"]["id"] == workspace_.id && window["mapped"].asBool();
-          });
-      swallowing_ = std::ranges::any_of(workspaceWindows, [&](const Json::Value& window) {
-        return !window["swallowing"].isNull() && window["swallowing"].asString() != "0x0";
-      });
-      std::vector<Json::Value> visibleWindows;
-      std::ranges::copy_if(workspaceWindows, std::back_inserter(visibleWindows),
-                           [&](const Json::Value& window) { return !window["hidden"].asBool(); });
-      solo_ = 1 == std::count_if(
-                       visibleWindows.begin(), visibleWindows.end(),
-                       [&](const Json::Value& window) { return !window["floating"].asBool(); });
-      allFloating_ = std::ranges::all_of(
-          visibleWindows, [&](const Json::Value& window) { return window["floating"].asBool(); });
-      fullscreen_ = windowData_.fullscreen;
-
-      // Fullscreen windows look like they are solo
-      if (fullscreen_) {
-        solo_ = true;
-      }
-
-      if (solo_) {
-        soloClass_ = windowData_.class_name;
-      } else {
-        soloClass_ = "";
-      }
-    }
-  } else {
-    focused_ = false;
-    windowData_ = WindowData{};
-    allFloating_ = false;
-    swallowing_ = false;
-    fullscreen_ = false;
-    solo_ = false;
-    soloClass_ = "";
+  if (solo_) {
+    soloClass_ = windowData_.class_name;
   }
 }
 

From dd47a2b826eecf31a66ed1c6a2caf769507cdca5 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Fri, 6 Mar 2026 18:33:17 -0600
Subject: [PATCH 32/63] fix(hyprland/workspaces): stabilize reload and event
 handling

Hyprland workspace reloads could stack duplicate scroll-event connections,
causing a single wheel gesture to switch multiple workspaces after repeated
config reloads. The persistent-workspaces monitor-array form also created the
monitor name instead of the configured workspace name.

Disconnect and replace the scroll handler on reinit, fix the persistent
workspace name selection, normalize urgent-window address matching, and reject
malformed workspace payloads before they corrupt the local state machine.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/hyprland/workspaces.hpp |  2 +
 src/modules/hyprland/workspaces.cpp     | 59 +++++++++++++++++--------
 2 files changed, 43 insertions(+), 18 deletions(-)

diff --git a/include/modules/hyprland/workspaces.hpp b/include/modules/hyprland/workspaces.hpp
index 0cec3c1d..03548ccb 100644
--- a/include/modules/hyprland/workspaces.hpp
+++ b/include/modules/hyprland/workspaces.hpp
@@ -4,6 +4,7 @@
 #include <gtkmm/enums.h>
 #include <gtkmm/label.h>
 #include <json/value.h>
+#include <sigc++/connection.h>
 
 #include <cstdint>
 #include <map>
@@ -208,6 +209,7 @@ class Workspaces : public AModule, public EventHandler {
   std::mutex m_mutex;
   const Bar& m_bar;
   Gtk::Box m_box;
+  sigc::connection m_scrollEventConnection_;
   IPC& m_ipc;
 };
 
diff --git a/src/modules/hyprland/workspaces.cpp b/src/modules/hyprland/workspaces.cpp
index cbd14f90..f794249b 100644
--- a/src/modules/hyprland/workspaces.cpp
+++ b/src/modules/hyprland/workspaces.cpp
@@ -34,6 +34,9 @@ Workspaces::Workspaces(const std::string& id, const Bar& bar, const Json::Value&
 }
 
 Workspaces::~Workspaces() {
+  if (m_scrollEventConnection_.connected()) {
+    m_scrollEventConnection_.disconnect();
+  }
   m_ipc.unregisterForIPC(this);
   // wait for possible event handler to finish
   std::lock_guard<std::mutex> lg(m_mutex);
@@ -44,10 +47,14 @@ void Workspaces::init() {
 
   initializeWorkspaces();
 
+  if (m_scrollEventConnection_.connected()) {
+    m_scrollEventConnection_.disconnect();
+  }
   if (barScroll()) {
     auto& window = const_cast<Bar&>(m_bar).window;
     window.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
-    window.signal_scroll_event().connect(sigc::mem_fun(*this, &Workspaces::handleScroll));
+    m_scrollEventConnection_ =
+        window.signal_scroll_event().connect(sigc::mem_fun(*this, &Workspaces::handleScroll));
   }
 
   dp.emit();
@@ -271,7 +278,7 @@ void Workspaces::loadPersistentWorkspacesFromConfig(Json::Value const& clientsJs
         // key is the workspace and value is array of monitors to create on
         for (const Json::Value& monitor : value) {
           if (monitor.isString() && monitor.asString() == currentMonitor) {
-            persistentWorkspacesToCreate.emplace_back(currentMonitor);
+            persistentWorkspacesToCreate.emplace_back(key);
             break;
           }
         }
@@ -332,8 +339,13 @@ void Workspaces::loadPersistentWorkspacesFromWorkspaceRules(const Json::Value& c
 
 void Workspaces::onEvent(const std::string& ev) {
   std::lock_guard<std::mutex> lock(m_mutex);
-  std::string eventName(begin(ev), begin(ev) + ev.find_first_of('>'));
-  std::string payload = ev.substr(eventName.size() + 2);
+  const auto separator = ev.find(">>");
+  if (separator == std::string::npos) {
+    spdlog::warn("Malformed Hyprland workspace event: {}", ev);
+    return;
+  }
+  std::string eventName = ev.substr(0, separator);
+  std::string payload = ev.substr(separator + 2);
 
   if (eventName == "workspacev2") {
     onWorkspaceActivated(payload);
@@ -496,19 +508,21 @@ void Workspaces::onMonitorFocused(std::string const& payload) {
 void Workspaces::onWindowOpened(std::string const& payload) {
   spdlog::trace("Window opened: {}", payload);
   updateWindowCount();
-  size_t lastCommaIdx = 0;
-  size_t nextCommaIdx = payload.find(',');
-  std::string windowAddress = payload.substr(lastCommaIdx, nextCommaIdx - lastCommaIdx);
+  const auto firstComma = payload.find(',');
+  const auto secondComma =
+      firstComma == std::string::npos ? std::string::npos : payload.find(',', firstComma + 1);
+  const auto thirdComma =
+      secondComma == std::string::npos ? std::string::npos : payload.find(',', secondComma + 1);
+  if (firstComma == std::string::npos || secondComma == std::string::npos ||
+      thirdComma == std::string::npos) {
+    spdlog::warn("Malformed Hyprland openwindow payload: {}", payload);
+    return;
+  }
 
-  lastCommaIdx = nextCommaIdx;
-  nextCommaIdx = payload.find(',', nextCommaIdx + 1);
-  std::string workspaceName = payload.substr(lastCommaIdx + 1, nextCommaIdx - lastCommaIdx - 1);
-
-  lastCommaIdx = nextCommaIdx;
-  nextCommaIdx = payload.find(',', nextCommaIdx + 1);
-  std::string windowClass = payload.substr(lastCommaIdx + 1, nextCommaIdx - lastCommaIdx - 1);
-
-  std::string windowTitle = payload.substr(nextCommaIdx + 1, payload.length() - nextCommaIdx);
+  std::string windowAddress = payload.substr(0, firstComma);
+  std::string workspaceName = payload.substr(firstComma + 1, secondComma - firstComma - 1);
+  std::string windowClass = payload.substr(secondComma + 1, thirdComma - secondComma - 1);
+  std::string windowTitle = payload.substr(thirdComma + 1);
 
   bool isActive = m_currentActiveWindowAddress == windowAddress;
   m_windowsToCreate.emplace_back(workspaceName, windowAddress, windowClass, windowTitle, isActive);
@@ -1002,10 +1016,12 @@ void Workspaces::sortWorkspaces() {
 
 void Workspaces::setUrgentWorkspace(std::string const& windowaddress) {
   const Json::Value clientsJson = m_ipc.getSocket1JsonReply("clients");
+  const std::string normalizedAddress =
+      windowaddress.starts_with("0x") ? windowaddress : fmt::format("0x{}", windowaddress);
   int workspaceId = -1;
 
   for (const auto& clientJson : clientsJson) {
-    if (clientJson["address"].asString().ends_with(windowaddress)) {
+    if (clientJson["address"].asString() == normalizedAddress) {
       workspaceId = clientJson["workspace"]["id"].asInt();
       break;
     }
@@ -1134,7 +1150,11 @@ std::string Workspaces::makePayload(Args const&... args) {
 }
 
 std::pair<std::string, std::string> Workspaces::splitDoublePayload(std::string const& payload) {
-  const std::string part1 = payload.substr(0, payload.find(','));
+  const auto separator = payload.find(',');
+  if (separator == std::string::npos) {
+    throw std::invalid_argument("Expected a two-part Hyprland payload");
+  }
+  const std::string part1 = payload.substr(0, separator);
   const std::string part2 = payload.substr(part1.size() + 1);
   return {part1, part2};
 }
@@ -1143,6 +1163,9 @@ std::tuple<std::string, std::string, std::string> Workspaces::splitTriplePayload
     std::string const& payload) {
   const size_t firstComma = payload.find(',');
   const size_t secondComma = payload.find(',', firstComma + 1);
+  if (firstComma == std::string::npos || secondComma == std::string::npos) {
+    throw std::invalid_argument("Expected a three-part Hyprland payload");
+  }
 
   const std::string part1 = payload.substr(0, firstComma);
   const std::string part2 = payload.substr(firstComma + 1, secondComma - (firstComma + 1));

From 6317022304a49c0033c52f0c6cdfe038e88dd314 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Fri, 6 Mar 2026 18:33:19 -0600
Subject: [PATCH 33/63] fix(hyprland): guard malformed module events

The language and submap modules assumed their Hyprland payload delimiters were
always present. When that assumption is violated, the old code could perform
invalid iterator math or throw while slicing the event string.

Validate the expected separators up front and bail out with a warning when the
event is malformed so the modules degrade safely instead of crashing the update
path.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/hyprland/language.cpp | 26 +++++++++++++++++++++-----
 src/modules/hyprland/submap.cpp   |  7 ++++++-
 2 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/src/modules/hyprland/language.cpp b/src/modules/hyprland/language.cpp
index 25f6789d..6e0fe23d 100644
--- a/src/modules/hyprland/language.cpp
+++ b/src/modules/hyprland/language.cpp
@@ -63,19 +63,35 @@ auto Language::update() -> void {
 
 void Language::onEvent(const std::string& ev) {
   std::lock_guard<std::mutex> lg(mutex_);
-  std::string kbName(begin(ev) + ev.find_last_of('>') + 1, begin(ev) + ev.find_first_of(','));
+  const auto payloadStart = ev.find(">>");
+  if (payloadStart == std::string::npos) {
+    spdlog::warn("hyprland language received malformed event: {}", ev);
+    return;
+  }
+  const auto payload = ev.substr(payloadStart + 2);
+  const auto kbSeparator = payload.find(',');
+  if (kbSeparator == std::string::npos) {
+    spdlog::warn("hyprland language received malformed event payload: {}", ev);
+    return;
+  }
+  std::string kbName = payload.substr(0, kbSeparator);
 
   // Last comma before variants parenthesis, eg:
   // activelayout>>micro-star-int'l-co.,-ltd.-msi-gk50-elite-gaming-keyboard,English (US, intl.,
   // with dead keys)
   std::string beforeParenthesis;
-  auto parenthesisPos = ev.find_last_of('(');
+  auto parenthesisPos = payload.find_last_of('(');
   if (parenthesisPos == std::string::npos) {
-    beforeParenthesis = ev;
+    beforeParenthesis = payload;
   } else {
-    beforeParenthesis = std::string(begin(ev), begin(ev) + parenthesisPos);
+    beforeParenthesis = payload.substr(0, parenthesisPos);
   }
-  auto layoutName = ev.substr(beforeParenthesis.find_last_of(',') + 1);
+  const auto layoutSeparator = beforeParenthesis.find_last_of(',');
+  if (layoutSeparator == std::string::npos) {
+    spdlog::warn("hyprland language received malformed layout payload: {}", ev);
+    return;
+  }
+  auto layoutName = payload.substr(layoutSeparator + 1);
 
   if (config_.isMember("keyboard-name") && kbName != config_["keyboard-name"].asString())
     return;  // ignore
diff --git a/src/modules/hyprland/submap.cpp b/src/modules/hyprland/submap.cpp
index ff18e7f3..36b9bf79 100644
--- a/src/modules/hyprland/submap.cpp
+++ b/src/modules/hyprland/submap.cpp
@@ -75,7 +75,12 @@ void Submap::onEvent(const std::string& ev) {
     return;
   }
 
-  auto submapName = ev.substr(ev.find_first_of('>') + 2);
+  const auto separator = ev.find(">>");
+  if (separator == std::string::npos) {
+    spdlog::warn("hyprland submap received malformed event: {}", ev);
+    return;
+  }
+  auto submapName = ev.substr(separator + 2);
 
   submap_ = submapName;
 

From 2a748f1a56ef9c49d3022657f7265ae4d3f65b46 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Sun, 8 Mar 2026 01:08:39 -0600
Subject: [PATCH 34/63] fix(sni): delay tray item insertion until proxies are
 ready

Only add tray widgets after the SNI proxy has finished initializing and the
item has a valid id/category pair.

This also removes invalid items through the host teardown path, refreshes the
tray when item status changes, and avoids calling DBus methods through a null
proxy during early clicks or scroll events.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/sni/host.hpp |  7 ++++-
 include/modules/sni/item.hpp | 14 +++++++++-
 include/modules/sni/tray.hpp |  1 +
 src/modules/sni/host.cpp     | 54 +++++++++++++++++++++++++++++++-----
 src/modules/sni/item.cpp     | 48 +++++++++++++++++++++++++++-----
 src/modules/sni/tray.cpp     |  5 +++-
 6 files changed, 112 insertions(+), 17 deletions(-)

diff --git a/include/modules/sni/host.hpp b/include/modules/sni/host.hpp
index 7248ad2f..d76ec74a 100644
--- a/include/modules/sni/host.hpp
+++ b/include/modules/sni/host.hpp
@@ -16,7 +16,7 @@ class Host {
  public:
   Host(const std::size_t id, const Json::Value&, const Bar&,
        const std::function<void(std::unique_ptr<Item>&)>&,
-       const std::function<void(std::unique_ptr<Item>&)>&);
+       const std::function<void(std::unique_ptr<Item>&)>&, const std::function<void()>&);
   ~Host();
 
  private:
@@ -28,6 +28,10 @@ class Host {
   static void registerHost(GObject*, GAsyncResult*, gpointer);
   static void itemRegistered(SnWatcher*, const gchar*, gpointer);
   static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
+  void itemReady(Item&);
+  void itemInvalidated(Item&);
+  void removeItem(std::vector<std::unique_ptr<Item>>::iterator);
+  void clearItems();
 
   std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
   void addRegisteredItem(const std::string& service);
@@ -43,6 +47,7 @@ class Host {
   const Bar& bar_;
   const std::function<void(std::unique_ptr<Item>&)> on_add_;
   const std::function<void(std::unique_ptr<Item>&)> on_remove_;
+  const std::function<void()> on_update_;
 };
 
 }  // namespace waybar::modules::SNI
diff --git a/include/modules/sni/item.hpp b/include/modules/sni/item.hpp
index 503ab637..43200fdb 100644
--- a/include/modules/sni/item.hpp
+++ b/include/modules/sni/item.hpp
@@ -11,6 +11,7 @@
 #include <libdbusmenu-gtk/dbusmenu-gtk.h>
 #include <sigc++/trackable.h>
 
+#include <functional>
 #include <set>
 #include <string_view>
 
@@ -25,9 +26,13 @@ struct ToolTip {
 
 class Item : public sigc::trackable {
  public:
-  Item(const std::string&, const std::string&, const Json::Value&, const Bar&);
+  Item(const std::string&, const std::string&, const Json::Value&, const Bar&,
+       const std::function<void(Item&)>&, const std::function<void(Item&)>&,
+       const std::function<void()>&);
   ~Item();
 
+  bool isReady() const;
+
   std::string bus_name;
   std::string object_path;
 
@@ -62,6 +67,8 @@ class Item : public sigc::trackable {
   void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
   void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
   void setStatus(const Glib::ustring& value);
+  void setReady();
+  void invalidate();
   void setCustomIcon(const std::string& id);
   void getUpdatedProperties();
   void processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& result);
@@ -86,8 +93,13 @@ class Item : public sigc::trackable {
   gdouble distance_scrolled_y_ = 0;
   // visibility of items with Status == Passive
   bool show_passive_ = false;
+  bool ready_ = false;
+  Glib::ustring status_ = "active";
 
   const Bar& bar_;
+  const std::function<void(Item&)> on_ready_;
+  const std::function<void(Item&)> on_invalidate_;
+  const std::function<void()> on_updated_;
 
   Glib::RefPtr<Gio::DBus::Proxy> proxy_;
   Glib::RefPtr<Gio::Cancellable> cancellable_;
diff --git a/include/modules/sni/tray.hpp b/include/modules/sni/tray.hpp
index 5f12d7f2..3d90b3fd 100644
--- a/include/modules/sni/tray.hpp
+++ b/include/modules/sni/tray.hpp
@@ -19,6 +19,7 @@ class Tray : public AModule {
  private:
   void onAdd(std::unique_ptr<Item>& item);
   void onRemove(std::unique_ptr<Item>& item);
+  void queueUpdate();
 
   static inline std::size_t nb_hosts_ = 0;
   bool show_passive_ = false;
diff --git a/src/modules/sni/host.cpp b/src/modules/sni/host.cpp
index 6bd1154a..18eac643 100644
--- a/src/modules/sni/host.cpp
+++ b/src/modules/sni/host.cpp
@@ -8,7 +8,8 @@ namespace waybar::modules::SNI {
 
 Host::Host(const std::size_t id, const Json::Value& config, const Bar& bar,
            const std::function<void(std::unique_ptr<Item>&)>& on_add,
-           const std::function<void(std::unique_ptr<Item>&)>& on_remove)
+           const std::function<void(std::unique_ptr<Item>&)>& on_remove,
+           const std::function<void()>& on_update)
     : bus_name_("org.kde.StatusNotifierHost-" + std::to_string(getpid()) + "-" +
                 std::to_string(id)),
       object_path_("/StatusNotifierHost/" + std::to_string(id)),
@@ -17,7 +18,8 @@ Host::Host(const std::size_t id, const Json::Value& config, const Bar& bar,
       config_(config),
       bar_(bar),
       on_add_(on_add),
-      on_remove_(on_remove) {}
+      on_remove_(on_remove),
+      on_update_(on_update) {}
 
 Host::~Host() {
   if (bus_name_id_ > 0) {
@@ -54,7 +56,7 @@ void Host::nameVanished(const Glib::RefPtr<Gio::DBus::Connection>& conn, const G
   g_cancellable_cancel(cancellable_);
   g_clear_object(&cancellable_);
   g_clear_object(&watcher_);
-  items_.clear();
+  clearItems();
 }
 
 void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) {
@@ -117,13 +119,50 @@ void Host::itemUnregistered(SnWatcher* watcher, const gchar* service, gpointer d
   auto [bus_name, object_path] = host->getBusNameAndObjectPath(service);
   for (auto it = host->items_.begin(); it != host->items_.end(); ++it) {
     if ((*it)->bus_name == bus_name && (*it)->object_path == object_path) {
-      host->on_remove_(*it);
-      host->items_.erase(it);
+      host->removeItem(it);
       break;
     }
   }
 }
 
+void Host::itemReady(Item& item) {
+  auto it = std::find_if(items_.begin(), items_.end(),
+                         [&item](const auto& candidate) { return candidate.get() == &item; });
+  if (it != items_.end() && (*it)->isReady()) {
+    on_add_(*it);
+  }
+}
+
+void Host::itemInvalidated(Item& item) {
+  auto it = std::find_if(items_.begin(), items_.end(),
+                         [&item](const auto& candidate) { return candidate.get() == &item; });
+  if (it != items_.end()) {
+    removeItem(it);
+  }
+}
+
+void Host::removeItem(std::vector<std::unique_ptr<Item>>::iterator it) {
+  if ((*it)->isReady()) {
+    on_remove_(*it);
+  }
+  items_.erase(it);
+}
+
+void Host::clearItems() {
+  bool removed_ready_item = false;
+  for (auto& item : items_) {
+    if (item->isReady()) {
+      on_remove_(item);
+      removed_ready_item = true;
+    }
+  }
+  bool had_items = !items_.empty();
+  items_.clear();
+  if (had_items && !removed_ready_item) {
+    on_update_();
+  }
+}
+
 std::tuple<std::string, std::string> Host::getBusNameAndObjectPath(const std::string service) {
   auto it = service.find('/');
   if (it != std::string::npos) {
@@ -139,8 +178,9 @@ void Host::addRegisteredItem(const std::string& service) {
     return bus_name == item->bus_name && object_path == item->object_path;
   });
   if (it == items_.end()) {
-    items_.emplace_back(new Item(bus_name, object_path, config_, bar_));
-    on_add_(items_.back());
+    items_.emplace_back(new Item(
+        bus_name, object_path, config_, bar_, [this](Item& item) { itemReady(item); },
+        [this](Item& item) { itemInvalidated(item); }, on_update_));
   }
 }
 
diff --git a/src/modules/sni/item.cpp b/src/modules/sni/item.cpp
index 1428bd8e..9820cc62 100644
--- a/src/modules/sni/item.cpp
+++ b/src/modules/sni/item.cpp
@@ -37,13 +37,18 @@ namespace waybar::modules::SNI {
 static const Glib::ustring SNI_INTERFACE_NAME = sn_item_interface_info()->name;
 static const unsigned UPDATE_DEBOUNCE_TIME = 10;
 
-Item::Item(const std::string& bn, const std::string& op, const Json::Value& config, const Bar& bar)
+Item::Item(const std::string& bn, const std::string& op, const Json::Value& config, const Bar& bar,
+           const std::function<void(Item&)>& on_ready,
+           const std::function<void(Item&)>& on_invalidate, const std::function<void()>& on_updated)
     : bus_name(bn),
       object_path(op),
       icon_size(16),
       effective_icon_size(0),
       icon_theme(Gtk::IconTheme::create()),
-      bar_(bar) {
+      bar_(bar),
+      on_ready_(on_ready),
+      on_invalidate_(on_invalidate),
+      on_updated_(on_updated) {
   if (config["icon-size"].isUInt()) {
     icon_size = config["icon-size"].asUInt();
   }
@@ -85,6 +90,8 @@ Item::~Item() {
   }
 }
 
+bool Item::isReady() const { return ready_; }
+
 bool Item::handleMouseEnter(GdkEventCrossing* const& e) {
   event_box.set_state_flags(Gtk::StateFlags::STATE_FLAG_PRELIGHT);
   return false;
@@ -112,14 +119,18 @@ void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
 
     if (this->id.empty() || this->category.empty()) {
       spdlog::error("Invalid Status Notifier Item: {}, {}", bus_name, object_path);
+      invalidate();
       return;
     }
     this->updateImage();
+    setReady();
 
   } catch (const Glib::Error& err) {
     spdlog::error("Failed to create DBus Proxy for {} {}: {}", bus_name, object_path, err.what());
+    invalidate();
   } catch (const std::exception& err) {
     spdlog::error("Failed to create DBus Proxy for {} {}: {}", bus_name, object_path, err.what());
+    invalidate();
   }
 }
 
@@ -217,18 +228,35 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
 }
 
 void Item::setStatus(const Glib::ustring& value) {
-  Glib::ustring lower = value.lowercase();
-  event_box.set_visible(show_passive_ || lower.compare("passive") != 0);
+  status_ = value.lowercase();
+  event_box.set_visible(show_passive_ || status_.compare("passive") != 0);
 
   auto style = event_box.get_style_context();
   for (const auto& class_name : style->list_classes()) {
     style->remove_class(class_name);
   }
-  if (lower.compare("needsattention") == 0) {
+  auto css_class = status_;
+  if (css_class.compare("needsattention") == 0) {
     // convert status to dash-case for CSS
-    lower = "needs-attention";
+    css_class = "needs-attention";
   }
-  style->add_class(lower);
+  style->add_class(css_class);
+  on_updated_();
+}
+
+void Item::setReady() {
+  if (ready_) {
+    return;
+  }
+  ready_ = true;
+  on_ready_(*this);
+}
+
+void Item::invalidate() {
+  if (ready_) {
+    ready_ = false;
+  }
+  on_invalidate_(*this);
 }
 
 void Item::setCustomIcon(const std::string& id) {
@@ -464,6 +492,9 @@ void Item::makeMenu() {
 }
 
 bool Item::handleClick(GdkEventButton* const& ev) {
+  if (!proxy_) {
+    return false;
+  }
   auto parameters = Glib::VariantContainerBase::create_tuple(
       {Glib::Variant<int>::create(ev->x_root + bar_.x_global),
        Glib::Variant<int>::create(ev->y_root + bar_.y_global)});
@@ -491,6 +522,9 @@ bool Item::handleClick(GdkEventButton* const& ev) {
 }
 
 bool Item::handleScroll(GdkEventScroll* const& ev) {
+  if (!proxy_) {
+    return false;
+  }
   int dx = 0, dy = 0;
   switch (ev->direction) {
     case GDK_SCROLL_UP:
diff --git a/src/modules/sni/tray.cpp b/src/modules/sni/tray.cpp
index 34a3c05f..114aba78 100644
--- a/src/modules/sni/tray.cpp
+++ b/src/modules/sni/tray.cpp
@@ -13,7 +13,8 @@ Tray::Tray(const std::string& id, const Bar& bar, const Json::Value& config)
       box_(bar.orientation, 0),
       watcher_(SNI::Watcher::getInstance()),
       host_(nb_hosts_, config, bar, std::bind(&Tray::onAdd, this, std::placeholders::_1),
-            std::bind(&Tray::onRemove, this, std::placeholders::_1)) {
+            std::bind(&Tray::onRemove, this, std::placeholders::_1),
+            std::bind(&Tray::queueUpdate, this)) {
   box_.set_name("tray");
   event_box_.add(box_);
   if (!id.empty()) {
@@ -33,6 +34,8 @@ Tray::Tray(const std::string& id, const Bar& bar, const Json::Value& config)
   dp.emit();
 }
 
+void Tray::queueUpdate() { dp.emit(); }
+
 void Tray::onAdd(std::unique_ptr<Item>& item) {
   if (config_["reverse-direction"].isBool() && config_["reverse-direction"].asBool()) {
     box_.pack_end(item->event_box);

From 78f6cde232147ee98986edd3cacfe9c6570bd7ec Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Sun, 8 Mar 2026 01:08:43 -0600
Subject: [PATCH 35/63] fix(sni): correct watcher host teardown signaling

Return the host registration method correctly on duplicate host registration
and emit HostUnregistered instead of HostRegistered when the last host
vanishes.

Also free the corresponding name watch once the tracked host/item disappears so
the watcher does not leak stale watch records.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/sni/watcher.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/modules/sni/watcher.cpp b/src/modules/sni/watcher.cpp
index 1534d924..66083c99 100644
--- a/src/modules/sni/watcher.cpp
+++ b/src/modules/sni/watcher.cpp
@@ -69,7 +69,7 @@ gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invoca
   if (watch != nullptr) {
     g_warning("Status Notifier Host with bus name '%s' and object path '%s' is already registered",
               bus_name, object_path);
-    sn_watcher_complete_register_item(obj->watcher_, invocation);
+    sn_watcher_complete_register_host(obj->watcher_, invocation);
     return TRUE;
   }
   watch = gfWatchNew(GF_WATCH_TYPE_HOST, service, bus_name, object_path, obj);
@@ -158,7 +158,7 @@ void Watcher::nameVanished(GDBusConnection* connection, const char* name, gpoint
     watch->watcher->hosts_ = g_slist_remove(watch->watcher->hosts_, watch);
     if (watch->watcher->hosts_ == nullptr) {
       sn_watcher_set_is_host_registered(watch->watcher->watcher_, FALSE);
-      sn_watcher_emit_host_registered(watch->watcher->watcher_);
+      sn_watcher_emit_host_unregistered(watch->watcher->watcher_);
     }
   } else if (watch->type == GF_WATCH_TYPE_ITEM) {
     watch->watcher->items_ = g_slist_remove(watch->watcher->items_, watch);
@@ -167,6 +167,7 @@ void Watcher::nameVanished(GDBusConnection* connection, const char* name, gpoint
     sn_watcher_emit_item_unregistered(watch->watcher->watcher_, tmp);
     g_free(tmp);
   }
+  gfWatchFree(watch);
 }
 
 void Watcher::updateRegisteredItems(SnWatcher* obj) {

From f6d92fd708d0fd87b008e3ed8005bc6b65fb3e05 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Sun, 8 Mar 2026 01:08:53 -0600
Subject: [PATCH 36/63] fix(sni): render attention and overlay tray icon assets

Load attention and overlay pixmaps from item properties, watch the
corresponding update signals, and prefer attention artwork while an item is in
NeedsAttention state.

When an item only exports an attention movie asset, fall back to loading that
asset as a static pixbuf so the tray still shows the alert state.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 include/modules/sni/item.hpp |   9 ++-
 src/modules/sni/item.cpp     | 110 +++++++++++++++++++++++++++--------
 2 files changed, 93 insertions(+), 26 deletions(-)

diff --git a/include/modules/sni/item.hpp b/include/modules/sni/item.hpp
index 43200fdb..74d54f4c 100644
--- a/include/modules/sni/item.hpp
+++ b/include/modules/sni/item.hpp
@@ -48,7 +48,9 @@ class Item : public sigc::trackable {
   Glib::RefPtr<Gdk::Pixbuf> icon_pixmap;
   Glib::RefPtr<Gtk::IconTheme> icon_theme;
   std::string overlay_icon_name;
+  Glib::RefPtr<Gdk::Pixbuf> overlay_icon_pixmap;
   std::string attention_icon_name;
+  Glib::RefPtr<Gdk::Pixbuf> attention_icon_pixmap;
   std::string attention_movie_name;
   std::string icon_theme_path;
   std::string menu;
@@ -76,8 +78,13 @@ class Item : public sigc::trackable {
                 const Glib::VariantContainerBase& arguments);
 
   void updateImage();
-  Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
+  static Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
   Glib::RefPtr<Gdk::Pixbuf> getIconPixbuf();
+  Glib::RefPtr<Gdk::Pixbuf> getAttentionIconPixbuf();
+  Glib::RefPtr<Gdk::Pixbuf> getOverlayIconPixbuf();
+  Glib::RefPtr<Gdk::Pixbuf> loadIconFromNameOrFile(const std::string& name, bool log_failure);
+  static Glib::RefPtr<Gdk::Pixbuf> overlayPixbufs(const Glib::RefPtr<Gdk::Pixbuf>&,
+                                                  const Glib::RefPtr<Gdk::Pixbuf>&);
   Glib::RefPtr<Gdk::Pixbuf> getIconByName(const std::string& name, int size);
   double getScaledIconSize();
   static void onMenuDestroyed(Item* self, GObject* old_menu_pointer);
diff --git a/src/modules/sni/item.cpp b/src/modules/sni/item.cpp
index 9820cc62..2f368083 100644
--- a/src/modules/sni/item.cpp
+++ b/src/modules/sni/item.cpp
@@ -5,6 +5,7 @@
 #include <gtkmm/tooltip.h>
 #include <spdlog/spdlog.h>
 
+#include <algorithm>
 #include <filesystem>
 #include <fstream>
 #include <map>
@@ -195,11 +196,11 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
     } else if (name == "OverlayIconName") {
       overlay_icon_name = get_variant<std::string>(value);
     } else if (name == "OverlayIconPixmap") {
-      // TODO: overlay_icon_pixmap
+      overlay_icon_pixmap = extractPixBuf(value.gobj());
     } else if (name == "AttentionIconName") {
       attention_icon_name = get_variant<std::string>(value);
     } else if (name == "AttentionIconPixmap") {
-      // TODO: attention_icon_pixmap
+      attention_icon_pixmap = extractPixBuf(value.gobj());
     } else if (name == "AttentionMovieName") {
       attention_movie_name = get_variant<std::string>(value);
     } else if (name == "ToolTip") {
@@ -315,8 +316,8 @@ void Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) {
 static const std::map<std::string_view, std::set<std::string_view>> signal2props = {
     {"NewTitle", {"Title"}},
     {"NewIcon", {"IconName", "IconPixmap"}},
-    // {"NewAttentionIcon", {"AttentionIconName", "AttentionIconPixmap", "AttentionMovieName"}},
-    // {"NewOverlayIcon", {"OverlayIconName", "OverlayIconPixmap"}},
+    {"NewAttentionIcon", {"AttentionIconName", "AttentionIconPixmap", "AttentionMovieName"}},
+    {"NewOverlayIcon", {"OverlayIconName", "OverlayIconPixmap"}},
     {"NewIconThemePath", {"IconThemePath"}},
     {"NewToolTip", {"ToolTip"}},
     {"NewStatus", {"Status"}},
@@ -406,36 +407,24 @@ void Item::updateImage() {
     pixbuf = pixbuf->scale_simple(width, scaled_icon_size, Gdk::InterpType::INTERP_BILINEAR);
   }
 
+  pixbuf = overlayPixbufs(pixbuf, getOverlayIconPixbuf());
+
   auto surface =
       Gdk::Cairo::create_surface_from_pixbuf(pixbuf, image.get_scale_factor(), image.get_window());
   image.set(surface);
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Item::getIconPixbuf() {
-  if (!icon_name.empty()) {
-    try {
-      std::ifstream temp(icon_name);
-      if (temp.is_open()) {
-        return Gdk::Pixbuf::create_from_file(icon_name);
-      }
-    } catch (Glib::Error& e) {
-      // Ignore because we want to also try different methods of getting an icon.
-      //
-      // But a warning is logged, as the file apparently exists, but there was
-      // a failure in creating a pixbuf out of it.
-
-      spdlog::warn("Item '{}': {}", id, static_cast<std::string>(e.what()));
-    }
-
-    try {
-      // Will throw if it can not find an icon.
-      return getIconByName(icon_name, getScaledIconSize());
-    } catch (Glib::Error& e) {
-      spdlog::trace("Item '{}': {}", id, static_cast<std::string>(e.what()));
+  if (status_ == "needsattention") {
+    if (auto attention_pixbuf = getAttentionIconPixbuf()) {
+      return attention_pixbuf;
     }
   }
 
-  // Return the pixmap only if an icon for the given name could not be found.
+  if (auto pixbuf = loadIconFromNameOrFile(icon_name, true)) {
+    return pixbuf;
+  }
+
   if (icon_pixmap) {
     return icon_pixmap;
   }
@@ -450,6 +439,77 @@ Glib::RefPtr<Gdk::Pixbuf> Item::getIconPixbuf() {
   return getIconByName("image-missing", getScaledIconSize());
 }
 
+Glib::RefPtr<Gdk::Pixbuf> Item::getAttentionIconPixbuf() {
+  if (auto pixbuf = loadIconFromNameOrFile(attention_icon_name, false)) {
+    return pixbuf;
+  }
+  if (auto pixbuf = loadIconFromNameOrFile(attention_movie_name, false)) {
+    return pixbuf;
+  }
+  return attention_icon_pixmap;
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Item::getOverlayIconPixbuf() {
+  if (auto pixbuf = loadIconFromNameOrFile(overlay_icon_name, false)) {
+    return pixbuf;
+  }
+  return overlay_icon_pixmap;
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Item::loadIconFromNameOrFile(const std::string& name, bool log_failure) {
+  if (name.empty()) {
+    return {};
+  }
+
+  try {
+    std::ifstream temp(name);
+    if (temp.is_open()) {
+      return Gdk::Pixbuf::create_from_file(name);
+    }
+  } catch (const Glib::Error& e) {
+    if (log_failure) {
+      spdlog::warn("Item '{}': {}", id, static_cast<std::string>(e.what()));
+    }
+  }
+
+  try {
+    return getIconByName(name, getScaledIconSize());
+  } catch (const Glib::Error& e) {
+    if (log_failure) {
+      spdlog::trace("Item '{}': {}", id, static_cast<std::string>(e.what()));
+    }
+  }
+
+  return {};
+}
+
+Glib::RefPtr<Gdk::Pixbuf> Item::overlayPixbufs(const Glib::RefPtr<Gdk::Pixbuf>& base,
+                                               const Glib::RefPtr<Gdk::Pixbuf>& overlay) {
+  if (!base || !overlay) {
+    return base;
+  }
+
+  auto composed = base->copy();
+  if (!composed) {
+    return base;
+  }
+
+  int overlay_target_size =
+      std::max(1, std::min(composed->get_width(), composed->get_height()) / 2);
+  auto scaled_overlay = overlay->scale_simple(overlay_target_size, overlay_target_size,
+                                              Gdk::InterpType::INTERP_BILINEAR);
+  if (!scaled_overlay) {
+    return composed;
+  }
+
+  int dest_x = std::max(0, composed->get_width() - scaled_overlay->get_width());
+  int dest_y = std::max(0, composed->get_height() - scaled_overlay->get_height());
+  scaled_overlay->composite(composed, dest_x, dest_y, scaled_overlay->get_width(),
+                            scaled_overlay->get_height(), dest_x, dest_y, 1.0, 1.0,
+                            Gdk::InterpType::INTERP_BILINEAR, 255);
+  return composed;
+}
+
 Glib::RefPtr<Gdk::Pixbuf> Item::getIconByName(const std::string& name, int request_size) {
   if (!icon_theme_path.empty()) {
     auto icon_info = icon_theme->lookup_icon(name.c_str(), request_size,

From 8e2e437ec665af43a7d16d80b53934ea3fefe733 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Sun, 8 Mar 2026 01:16:25 -0600
Subject: [PATCH 37/63] fix(sni): silence duplicate item registration warnings

Some tray items re-register the same bus name and object path during normal
operation. Treat that path as an idempotent registration instead of logging a
warning, while still completing the DBus method successfully.

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 src/modules/sni/watcher.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/modules/sni/watcher.cpp b/src/modules/sni/watcher.cpp
index 66083c99..969806cf 100644
--- a/src/modules/sni/watcher.cpp
+++ b/src/modules/sni/watcher.cpp
@@ -98,8 +98,8 @@ gboolean Watcher::handleRegisterItem(Watcher* obj, GDBusMethodInvocation* invoca
   }
   auto watch = gfWatchFind(obj->items_, bus_name, object_path);
   if (watch != nullptr) {
-    g_warning("Status Notifier Item with bus name '%s' and object path '%s' is already registered",
-              bus_name, object_path);
+    spdlog::debug("Ignoring duplicate Status Notifier Item registration for '{}' at '{}'", bus_name,
+                  object_path);
     sn_watcher_complete_register_item(obj->watcher_, invocation);
     return TRUE;
   }

From 558c2753d79bcbaa87ef4c3c2cf4f63578bd6484 Mon Sep 17 00:00:00 2001
From: Visal Vijay <visalvijay83@gmail.com>
Date: Mon, 16 Mar 2026 21:04:59 +0530
Subject: [PATCH 38/63] Add simple calendar tooltip example for clock module

---
 man/waybar-clock.5.scd | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/man/waybar-clock.5.scd b/man/waybar-clock.5.scd
index b4b5d5b7..5c5509f6 100644
--- a/man/waybar-clock.5.scd
+++ b/man/waybar-clock.5.scd
@@ -259,7 +259,19 @@ View all valid format options in *strftime(3)* or have a look https://en.cpprefe
 	"tooltip-format": "{tz_list}"
 }
 ```
+5. Simple calendar tooltip
 
+```
+"clock": {
+"format": "{:%H:%M}",
+"tooltip-format": "<tt>{calendar}</tt>",
+"calendar": {
+"format": {
+"today": "<span color='#ffcc66'><b>{}</b></span>"
+}
+}
+}
+```
 # STYLE
 
 - *#clock*

From 3cfb62266033f8266f09d861e88845c55ac2777c Mon Sep 17 00:00:00 2001
From: Visal Vijay <visalvijay83@gmail.com>
Date: Mon, 16 Mar 2026 23:45:28 +0530
Subject: [PATCH 39/63] Fix menu-actions GTK callback pointer handling

---
 src/ALabel.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/ALabel.cpp b/src/ALabel.cpp
index 795f87f1..e6f46d94 100644
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@@ -116,8 +116,9 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
         }
         submenus_[key] = GTK_MENU_ITEM(item);
         menuActionsMap_[key] = it->asString();
-        g_signal_connect(submenus_[key], "activate", G_CALLBACK(handleGtkMenuEvent),
-                         (gpointer)menuActionsMap_[key].c_str());
+        g_signal_connect(submenus_[key], "activate",
+                 G_CALLBACK(handleGtkMenuEvent),
+                 (gpointer)menuActionsMap_[key].c_str());              
       }
       g_object_unref(builder);
     } catch (std::runtime_error& e) {

From acf6f117eabb92b0e3cba35d7499635ccd36c8a9 Mon Sep 17 00:00:00 2001
From: Visal Vijay <150381094+B2krobbery@users.noreply.github.com>
Date: Tue, 17 Mar 2026 01:13:14 +0530
Subject: [PATCH 40/63] Update ALabel.cpp

---
 src/ALabel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ALabel.cpp b/src/ALabel.cpp
index e6f46d94..7f34bca3 100644
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@@ -118,7 +118,7 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
         menuActionsMap_[key] = it->asString();
         g_signal_connect(submenus_[key], "activate",
                  G_CALLBACK(handleGtkMenuEvent),
-                 (gpointer)menuActionsMap_[key].c_str());              
+                 (gpointer)g_strdup(menuActionsMap_[key].c_str()));             
       }
       g_object_unref(builder);
     } catch (std::runtime_error& e) {

From 196589cf321ef4fdf848d18f1e249199bc7821e9 Mon Sep 17 00:00:00 2001
From: Visal Vijay <150381094+B2krobbery@users.noreply.github.com>
Date: Tue, 17 Mar 2026 01:17:08 +0530
Subject: [PATCH 41/63] Update ALabel.cpp

---
 src/ALabel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ALabel.cpp b/src/ALabel.cpp
index 7f34bca3..b23926d8 100644
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@@ -118,7 +118,7 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
         menuActionsMap_[key] = it->asString();
         g_signal_connect(submenus_[key], "activate",
                  G_CALLBACK(handleGtkMenuEvent),
-                 (gpointer)g_strdup(menuActionsMap_[key].c_str()));             
+                 (gpointer)g_strdup(menuActionsMap_[key].c_str()));          
       }
       g_object_unref(builder);
     } catch (std::runtime_error& e) {

From d046c19b855853dc08ef1bb7abdb6c16f9a420b4 Mon Sep 17 00:00:00 2001
From: Carlo Teubner <carlo@cteubner.net>
Date: Tue, 17 Mar 2026 21:33:21 +0000
Subject: [PATCH 42/63] systemd-failed-units: small tweaks

- Remove unneeded destructor impl
- Rename member variables for consistench with other files
- manpage wording fixes
- updateData(): small logic tweak
---
 include/modules/systemd_failed_units.hpp | 16 ++---
 man/waybar-systemd-failed-units.5.scd    | 16 ++---
 src/modules/systemd_failed_units.cpp     | 91 +++++++++++++-----------
 3 files changed, 64 insertions(+), 59 deletions(-)

diff --git a/include/modules/systemd_failed_units.hpp b/include/modules/systemd_failed_units.hpp
index ffb25082..fdc6eb8e 100644
--- a/include/modules/systemd_failed_units.hpp
+++ b/include/modules/systemd_failed_units.hpp
@@ -11,18 +11,18 @@ namespace waybar::modules {
 class SystemdFailedUnits : public ALabel {
  public:
   SystemdFailedUnits(const std::string&, const Json::Value&);
-  virtual ~SystemdFailedUnits();
+  virtual ~SystemdFailedUnits() = default;
   auto update() -> void override;
 
  private:
-  bool hide_on_ok;
-  std::string format_ok;
+  bool hide_on_ok_;
+  std::string format_ok_;
 
-  bool update_pending;
-  std::string system_state, user_state, overall_state;
-  uint32_t nr_failed_system, nr_failed_user, nr_failed;
-  std::string last_status;
-  Glib::RefPtr<Gio::DBus::Proxy> system_proxy, user_proxy;
+  bool update_pending_;
+  std::string system_state_, user_state_, overall_state_;
+  uint32_t nr_failed_system_, nr_failed_user_, nr_failed_;
+  std::string last_status_;
+  Glib::RefPtr<Gio::DBus::Proxy> system_props_proxy_, user_props_proxy_;
 
   void notify_cb(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
                  const Glib::VariantContainerBase& arguments);
diff --git a/man/waybar-systemd-failed-units.5.scd b/man/waybar-systemd-failed-units.5.scd
index 8d7c980a..f99283f2 100644
--- a/man/waybar-systemd-failed-units.5.scd
+++ b/man/waybar-systemd-failed-units.5.scd
@@ -19,7 +19,7 @@ Addressed by *systemd-failed-units*
 
 *format-ok*: ++
 	typeof: string ++
-	This format is used when there is no failing units.
+	This format is used when there are no failing units.
 
 *user*: ++
 	typeof: bool ++
@@ -34,15 +34,15 @@ Addressed by *systemd-failed-units*
 *hide-on-ok*: ++
 	typeof: bool ++
 	default: *true* ++
-	Option to hide this module when there is no failing units.
+	Option to hide this module when there are no failed units.
 
 *menu*: ++
 	typeof: string ++
-	Action that popups the menu.
+	Action that pops up the menu.
 
 *menu-file*: ++
 	typeof: string ++
-	Location of the menu descriptor file. There need to be an element of type
+	Location of the menu descriptor file. There needs to be an element of type
 	GtkMenu with id *menu*
 
 *menu-actions*: ++
@@ -52,7 +52,7 @@ Addressed by *systemd-failed-units*
 *expand*: ++
 	typeof: bool ++
 	default: false ++
-	Enables this module to consume all left over space dynamically.
+	Enables this module to consume all leftover space dynamically.
 
 # FORMAT REPLACEMENTS
 
@@ -62,11 +62,11 @@ Addressed by *systemd-failed-units*
 
 *{nr_failed}*: Number of total failed units.
 
-*{systemd_state}:* State of the systemd system session
+*{system_state}:* State of the systemd system session.
 
-*{user_state}:* State of the systemd user session
+*{user_state}:* State of the systemd user session.
 
-*{overall_state}:* Overall state of the systemd and user session. ("Ok" or "Degraded")
+*{overall_state}:* Overall state of the systemd and user session. ("ok" or "degraded")
 
 # EXAMPLES
 
diff --git a/src/modules/systemd_failed_units.cpp b/src/modules/systemd_failed_units.cpp
index 68e61fe9..44e66393 100644
--- a/src/modules/systemd_failed_units.cpp
+++ b/src/modules/systemd_failed_units.cpp
@@ -1,10 +1,12 @@
 #include "modules/systemd_failed_units.hpp"
 
+#include <fmt/format.h>
 #include <giomm/dbusproxy.h>
 #include <glibmm/variant.h>
 #include <spdlog/spdlog.h>
 
 #include <cstdint>
+#include <stdexcept>
 
 static const unsigned UPDATE_DEBOUNCE_TIME_MS = 1000;
 
@@ -12,39 +14,41 @@ namespace waybar::modules {
 
 SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value& config)
     : ALabel(config, "systemd-failed-units", id, "{nr_failed} failed", 1),
-      hide_on_ok(true),
-      update_pending(false),
-      nr_failed_system(0),
-      nr_failed_user(0),
-      nr_failed(0),
-      last_status() {
+      hide_on_ok_(true),
+      update_pending_(false),
+      nr_failed_system_(0),
+      nr_failed_user_(0),
+      nr_failed_(0),
+      last_status_() {
   if (config["hide-on-ok"].isBool()) {
-    hide_on_ok = config["hide-on-ok"].asBool();
+    hide_on_ok_ = config["hide-on-ok"].asBool();
   }
   if (config["format-ok"].isString()) {
-    format_ok = config["format-ok"].asString();
+    format_ok_ = config["format-ok"].asString();
   } else {
-    format_ok = format_;
+    format_ok_ = format_;
   }
 
   /* Default to enable both "system" and "user". */
   if (!config["system"].isBool() || config["system"].asBool()) {
-    system_proxy = Gio::DBus::Proxy::create_for_bus_sync(
+    system_props_proxy_ = Gio::DBus::Proxy::create_for_bus_sync(
         Gio::DBus::BusType::BUS_TYPE_SYSTEM, "org.freedesktop.systemd1",
         "/org/freedesktop/systemd1", "org.freedesktop.DBus.Properties");
-    if (!system_proxy) {
+    if (!system_props_proxy_) {
       throw std::runtime_error("Unable to connect to systemwide systemd DBus!");
     }
-    system_proxy->signal_signal().connect(sigc::mem_fun(*this, &SystemdFailedUnits::notify_cb));
+    system_props_proxy_->signal_signal().connect(
+        sigc::mem_fun(*this, &SystemdFailedUnits::notify_cb));
   }
   if (!config["user"].isBool() || config["user"].asBool()) {
-    user_proxy = Gio::DBus::Proxy::create_for_bus_sync(
+    user_props_proxy_ = Gio::DBus::Proxy::create_for_bus_sync(
         Gio::DBus::BusType::BUS_TYPE_SESSION, "org.freedesktop.systemd1",
         "/org/freedesktop/systemd1", "org.freedesktop.DBus.Properties");
-    if (!user_proxy) {
+    if (!user_props_proxy_) {
       throw std::runtime_error("Unable to connect to user systemd DBus!");
     }
-    user_proxy->signal_signal().connect(sigc::mem_fun(*this, &SystemdFailedUnits::notify_cb));
+    user_props_proxy_->signal_signal().connect(
+        sigc::mem_fun(*this, &SystemdFailedUnits::notify_cb));
   }
 
   updateData();
@@ -52,16 +56,11 @@ SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value&
   dp.emit();
 }
 
-SystemdFailedUnits::~SystemdFailedUnits() {
-  if (system_proxy) system_proxy.reset();
-  if (user_proxy) user_proxy.reset();
-}
-
 auto SystemdFailedUnits::notify_cb(const Glib::ustring& sender_name,
                                    const Glib::ustring& signal_name,
                                    const Glib::VariantContainerBase& arguments) -> void {
-  if (signal_name == "PropertiesChanged" && !update_pending) {
-    update_pending = true;
+  if (signal_name == "PropertiesChanged" && !update_pending_) {
+    update_pending_ = true;
     /* The fail count may fluctuate due to restarting. */
     Glib::signal_timeout().connect_once(sigc::mem_fun(*this, &SystemdFailedUnits::updateData),
                                         UPDATE_DEBOUNCE_TIME_MS);
@@ -88,12 +87,12 @@ void SystemdFailedUnits::RequestSystemState() {
     return "unknown";
   };
 
-  system_state = load("systemwide", system_proxy);
-  user_state = load("user", user_proxy);
-  if (system_state == "running" && user_state == "running")
-    overall_state = "ok";
+  system_state_ = load("systemwide", system_props_proxy_);
+  user_state_ = load("user", user_props_proxy_);
+  if (system_state_ == "running" && user_state_ == "running")
+    overall_state_ = "ok";
   else
-    overall_state = "degraded";
+    overall_state_ = "degraded";
 }
 
 void SystemdFailedUnits::RequestFailedUnits() {
@@ -116,25 +115,31 @@ void SystemdFailedUnits::RequestFailedUnits() {
     return 0;
   };
 
-  nr_failed_system = load("systemwide", system_proxy);
-  nr_failed_user = load("user", user_proxy);
-  nr_failed = nr_failed_system + nr_failed_user;
+  nr_failed_system_ = load("systemwide", system_props_proxy_);
+  nr_failed_user_ = load("user", user_props_proxy_);
+  nr_failed_ = nr_failed_system_ + nr_failed_user_;
 }
 
 void SystemdFailedUnits::updateData() {
-  update_pending = false;
+  update_pending_ = false;
 
   RequestSystemState();
-  if (overall_state == "degraded") RequestFailedUnits();
+  if (overall_state_ == "degraded") {
+    RequestFailedUnits();
+  } else {
+    nr_failed_system_ = 0;
+    nr_failed_user_ = 0;
+    nr_failed_ = 0;
+  }
 
   dp.emit();
 }
 
 auto SystemdFailedUnits::update() -> void {
-  if (last_status == overall_state) return;
+  if (last_status_ == overall_state_) return;
 
   // Hide if needed.
-  if (overall_state == "ok" && hide_on_ok) {
+  if (overall_state_ == "ok" && hide_on_ok_) {
     event_box_.set_visible(false);
     return;
   }
@@ -142,20 +147,20 @@ auto SystemdFailedUnits::update() -> void {
   event_box_.set_visible(true);
 
   // Set state class.
-  if (!last_status.empty() && label_.get_style_context()->has_class(last_status)) {
-    label_.get_style_context()->remove_class(last_status);
+  if (!last_status_.empty() && label_.get_style_context()->has_class(last_status_)) {
+    label_.get_style_context()->remove_class(last_status_);
   }
-  if (!label_.get_style_context()->has_class(overall_state)) {
-    label_.get_style_context()->add_class(overall_state);
+  if (!label_.get_style_context()->has_class(overall_state_)) {
+    label_.get_style_context()->add_class(overall_state_);
   }
 
-  last_status = overall_state;
+  last_status_ = overall_state_;
 
   label_.set_markup(fmt::format(
-      fmt::runtime(nr_failed == 0 ? format_ok : format_), fmt::arg("nr_failed", nr_failed),
-      fmt::arg("nr_failed_system", nr_failed_system), fmt::arg("nr_failed_user", nr_failed_user),
-      fmt::arg("system_state", system_state), fmt::arg("user_state", user_state),
-      fmt::arg("overall_state", overall_state)));
+      fmt::runtime(nr_failed_ == 0 ? format_ok_ : format_), fmt::arg("nr_failed", nr_failed_),
+      fmt::arg("nr_failed_system", nr_failed_system_),
+      fmt::arg("nr_failed_user", nr_failed_user_), fmt::arg("system_state", system_state_),
+      fmt::arg("user_state", user_state_), fmt::arg("overall_state", overall_state_)));
   ALabel::update();
 }
 

From 3b1262061da2276c208c7241205d6326deda8c58 Mon Sep 17 00:00:00 2001
From: Carlo Teubner <carlo@cteubner.net>
Date: Tue, 17 Mar 2026 21:33:41 +0000
Subject: [PATCH 43/63] systemd-failed-units: tooltip w/ failed units list

---
 include/modules/systemd_failed_units.hpp |  20 +++
 man/waybar-systemd-failed-units.5.scd    |  29 +++++
 src/modules/systemd_failed_units.cpp     | 148 ++++++++++++++++++++++-
 3 files changed, 192 insertions(+), 5 deletions(-)

diff --git a/include/modules/systemd_failed_units.hpp b/include/modules/systemd_failed_units.hpp
index fdc6eb8e..3eda799a 100644
--- a/include/modules/systemd_failed_units.hpp
+++ b/include/modules/systemd_failed_units.hpp
@@ -3,6 +3,7 @@
 #include <giomm/dbusproxy.h>
 
 #include <string>
+#include <vector>
 
 #include "ALabel.hpp"
 
@@ -15,19 +16,38 @@ class SystemdFailedUnits : public ALabel {
   auto update() -> void override;
 
  private:
+  struct FailedUnit {
+    std::string name;
+    std::string description;
+    std::string load_state;
+    std::string active_state;
+    std::string sub_state;
+    std::string scope;
+  };
+
   bool hide_on_ok_;
   std::string format_ok_;
+  std::string tooltip_format_;
+  std::string tooltip_format_ok_;
+  std::string tooltip_unit_format_;
 
   bool update_pending_;
   std::string system_state_, user_state_, overall_state_;
   uint32_t nr_failed_system_, nr_failed_user_, nr_failed_;
   std::string last_status_;
   Glib::RefPtr<Gio::DBus::Proxy> system_props_proxy_, user_props_proxy_;
+  Glib::RefPtr<Gio::DBus::Proxy> system_manager_proxy_, user_manager_proxy_;
+  std::vector<FailedUnit> failed_units_;
 
   void notify_cb(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
                  const Glib::VariantContainerBase& arguments);
   void RequestFailedUnits();
+  void RequestFailedUnitsList();
   void RequestSystemState();
+  std::vector<FailedUnit> LoadFailedUnitsList(const char* kind,
+                                              Glib::RefPtr<Gio::DBus::Proxy>& proxy,
+                                              const std::string& scope);
+  std::string BuildTooltipFailedList() const;
   void updateData();
 };
 
diff --git a/man/waybar-systemd-failed-units.5.scd b/man/waybar-systemd-failed-units.5.scd
index f99283f2..aaeee2d1 100644
--- a/man/waybar-systemd-failed-units.5.scd
+++ b/man/waybar-systemd-failed-units.5.scd
@@ -36,6 +36,21 @@ Addressed by *systemd-failed-units*
 	default: *true* ++
 	Option to hide this module when there are no failed units.
 
+*tooltip-format*: ++
+	typeof: string ++
+	default: *System: {system_state}\nUser: {user_state}\nFailed units ({nr_failed}):\n{failed_units_list}* ++
+	Tooltip format shown when there are failed units.
+
+*tooltip-format-ok*: ++
+	typeof: string ++
+	default: *System: {system_state}\nUser: {user_state}* ++
+	Tooltip format used when there are no failed units.
+
+*tooltip-unit-format*: ++
+	typeof: string ++
+	default: *{name}: {description}* ++
+	Format used to render each failed unit inside the tooltip. Each item is prefixed with a bullet.
+
 *menu*: ++
 	typeof: string ++
 	Action that pops up the menu.
@@ -68,6 +83,18 @@ Addressed by *systemd-failed-units*
 
 *{overall_state}:* Overall state of the systemd and user session. ("ok" or "degraded")
 
+*{failed_units_list}:* Bulleted list of failed units using *tooltip-unit-format*. Empty when
+there are no failed units.
+
+The *tooltip-unit-format* string supports the following replacements:
+
+*{name}*: Unit name ++
+*{description}*: Unit description ++
+*{load_state}*: Unit load state ++
+*{active_state}*: Unit active state ++
+*{sub_state}*: Unit sub state ++
+*{scope}*: Either *system* or *user* depending on where the unit originated
+
 # EXAMPLES
 
 ```
@@ -77,6 +104,8 @@ Addressed by *systemd-failed-units*
 	"format-ok": "✓",
 	"system": true,
 	"user": false,
+	"tooltip-format": "{nr_failed} failed units:\n{failed_units_list}",
+	"tooltip-unit-format": "{scope}: {name} ({active_state})",
 }
 ```
 
diff --git a/src/modules/systemd_failed_units.cpp b/src/modules/systemd_failed_units.cpp
index 44e66393..600d0fb1 100644
--- a/src/modules/systemd_failed_units.cpp
+++ b/src/modules/systemd_failed_units.cpp
@@ -2,11 +2,14 @@
 
 #include <fmt/format.h>
 #include <giomm/dbusproxy.h>
+#include <glibmm/markup.h>
 #include <glibmm/variant.h>
 #include <spdlog/spdlog.h>
 
 #include <cstdint>
+#include <exception>
 #include <stdexcept>
+#include <tuple>
 
 static const unsigned UPDATE_DEBOUNCE_TIME_MS = 1000;
 
@@ -15,6 +18,10 @@ namespace waybar::modules {
 SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value& config)
     : ALabel(config, "systemd-failed-units", id, "{nr_failed} failed", 1),
       hide_on_ok_(true),
+      tooltip_format_("System: {system_state}\nUser: {user_state}\nFailed units ({nr_failed}):\n"
+                       "{failed_units_list}"),
+      tooltip_format_ok_("System: {system_state}\nUser: {user_state}"),
+      tooltip_unit_format_("{name}: {description}"),
       update_pending_(false),
       nr_failed_system_(0),
       nr_failed_user_(0),
@@ -29,6 +36,16 @@ SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value&
     format_ok_ = format_;
   }
 
+  if (config["tooltip-format"].isString()) {
+    tooltip_format_ = config["tooltip-format"].asString();
+  }
+  if (config["tooltip-format-ok"].isString()) {
+    tooltip_format_ok_ = config["tooltip-format-ok"].asString();
+  }
+  if (config["tooltip-unit-format"].isString()) {
+    tooltip_unit_format_ = config["tooltip-unit-format"].asString();
+  }
+
   /* Default to enable both "system" and "user". */
   if (!config["system"].isBool() || config["system"].asBool()) {
     system_props_proxy_ = Gio::DBus::Proxy::create_for_bus_sync(
@@ -39,6 +56,14 @@ SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value&
     }
     system_props_proxy_->signal_signal().connect(
         sigc::mem_fun(*this, &SystemdFailedUnits::notify_cb));
+    try {
+      system_manager_proxy_ = Gio::DBus::Proxy::create_for_bus_sync(
+          Gio::DBus::BusType::BUS_TYPE_SYSTEM, "org.freedesktop.systemd1",
+          "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager");
+    } catch (const Glib::Error& e) {
+      spdlog::warn("Unable to connect to systemwide systemd Manager interface: {}",
+                   e.what().c_str());
+    }
   }
   if (!config["user"].isBool() || config["user"].asBool()) {
     user_props_proxy_ = Gio::DBus::Proxy::create_for_bus_sync(
@@ -49,6 +74,13 @@ SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value&
     }
     user_props_proxy_->signal_signal().connect(
         sigc::mem_fun(*this, &SystemdFailedUnits::notify_cb));
+    try {
+      user_manager_proxy_ = Gio::DBus::Proxy::create_for_bus_sync(
+          Gio::DBus::BusType::BUS_TYPE_SESSION, "org.freedesktop.systemd1",
+          "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager");
+    } catch (const Glib::Error& e) {
+      spdlog::warn("Unable to connect to user systemd Manager interface: {}", e.what().c_str());
+    }
   }
 
   updateData();
@@ -120,27 +152,117 @@ void SystemdFailedUnits::RequestFailedUnits() {
   nr_failed_ = nr_failed_system_ + nr_failed_user_;
 }
 
+void SystemdFailedUnits::RequestFailedUnitsList() {
+  failed_units_.clear();
+  if (!tooltipEnabled() || nr_failed_ == 0) {
+    return;
+  }
+
+  if (system_manager_proxy_) {
+    auto units = LoadFailedUnitsList("systemwide", system_manager_proxy_, "system");
+    failed_units_.insert(failed_units_.end(), units.begin(), units.end());
+  }
+  if (user_manager_proxy_) {
+    auto units = LoadFailedUnitsList("user", user_manager_proxy_, "user");
+    failed_units_.insert(failed_units_.end(), units.begin(), units.end());
+  }
+}
+
+auto SystemdFailedUnits::LoadFailedUnitsList(const char* kind,
+                                             Glib::RefPtr<Gio::DBus::Proxy>& proxy,
+                                             const std::string& scope)
+    -> std::vector<FailedUnit> {
+  // org.freedesktop.systemd1.Manager.ListUnits returns
+  // (name, description, load_state, active_state, sub_state, followed, unit_path, job_id,
+  //  job_type, job_path).
+  using UnitRow = std::tuple<Glib::ustring, Glib::ustring, Glib::ustring, Glib::ustring,
+                             Glib::ustring, Glib::ustring, Glib::DBusObjectPathString, guint32,
+                             Glib::ustring, Glib::DBusObjectPathString>;
+  using ListUnitsReply = Glib::Variant<std::tuple<std::vector<UnitRow>>>;
+
+  std::vector<FailedUnit> units;
+  if (!proxy) {
+    return units;
+  }
+
+  try {
+    auto data = proxy->call_sync("ListUnits");
+    if (!data) return units;
+    if (!data.is_of_type(ListUnitsReply::variant_type())) {
+      spdlog::warn("Unexpected DBus signature for ListUnits: {}", data.get_type_string());
+      return units;
+    }
+
+    auto [rows] = Glib::VariantBase::cast_dynamic<ListUnitsReply>(data).get();
+    for (const auto& row : rows) {
+      const auto& name = std::get<0>(row);
+      const auto& description = std::get<1>(row);
+      const auto& load_state = std::get<2>(row);
+      const auto& active_state = std::get<3>(row);
+      const auto& sub_state = std::get<4>(row);
+      if (active_state == "failed" || sub_state == "failed") {
+        units.push_back({name, description, load_state, active_state, sub_state, scope});
+      }
+    }
+  } catch (const Glib::Error& e) {
+    spdlog::error("Failed to list {} units: {}", kind, e.what().c_str());
+  }
+
+  return units;
+}
+
+std::string SystemdFailedUnits::BuildTooltipFailedList() const {
+  if (failed_units_.empty()) {
+    return "";
+  }
+
+  std::string list;
+  list.reserve(failed_units_.size() * 16);
+  bool first = true;
+  for (const auto& unit : failed_units_) {
+    try {
+      auto line = fmt::format(
+          fmt::runtime(tooltip_unit_format_),
+          fmt::arg("name", Glib::Markup::escape_text(unit.name).raw()),
+          fmt::arg("description", Glib::Markup::escape_text(unit.description).raw()),
+          fmt::arg("load_state", unit.load_state),
+          fmt::arg("active_state", unit.active_state),
+          fmt::arg("sub_state", unit.sub_state),
+          fmt::arg("scope", unit.scope));
+      if (!first) {
+        list += "\n";
+      }
+      first = false;
+      list += "- ";
+      list += line;
+    } catch (const std::exception& e) {
+      spdlog::warn("Failed to format tooltip for unit {}: {}", unit.name, e.what());
+    }
+  }
+
+  return list;
+}
+
 void SystemdFailedUnits::updateData() {
   update_pending_ = false;
 
   RequestSystemState();
   if (overall_state_ == "degraded") {
     RequestFailedUnits();
+    RequestFailedUnitsList();
   } else {
-    nr_failed_system_ = 0;
-    nr_failed_user_ = 0;
-    nr_failed_ = 0;
+    nr_failed_system_ = nr_failed_user_ = nr_failed_ = 0;
+    failed_units_.clear();
   }
 
   dp.emit();
 }
 
 auto SystemdFailedUnits::update() -> void {
-  if (last_status_ == overall_state_) return;
-
   // Hide if needed.
   if (overall_state_ == "ok" && hide_on_ok_) {
     event_box_.set_visible(false);
+    last_status_ = overall_state_;
     return;
   }
 
@@ -161,6 +283,22 @@ auto SystemdFailedUnits::update() -> void {
       fmt::arg("nr_failed_system", nr_failed_system_),
       fmt::arg("nr_failed_user", nr_failed_user_), fmt::arg("system_state", system_state_),
       fmt::arg("user_state", user_state_), fmt::arg("overall_state", overall_state_)));
+  if (tooltipEnabled()) {
+    std::string failed_list = BuildTooltipFailedList();
+    auto tooltip_template = overall_state_ == "ok" ? tooltip_format_ok_ : tooltip_format_;
+    if (!tooltip_template.empty()) {
+      label_.set_tooltip_markup(
+          fmt::format(fmt::runtime(tooltip_template), fmt::arg("nr_failed", nr_failed_),
+                      fmt::arg("nr_failed_system", nr_failed_system_),
+                      fmt::arg("nr_failed_user", nr_failed_user_),
+                      fmt::arg("system_state", system_state_),
+                      fmt::arg("user_state", user_state_),
+                      fmt::arg("overall_state", overall_state_),
+                      fmt::arg("failed_units_list", failed_list)));
+    } else {
+      label_.set_tooltip_text("");
+    }
+  }
   ALabel::update();
 }
 

From e7c077ab9a5cd959bd412d18df84462cbd97e3b1 Mon Sep 17 00:00:00 2001
From: Carlo Teubner <carlo@cteubner.net>
Date: Tue, 17 Mar 2026 21:39:55 +0000
Subject: [PATCH 44/63] clang-format

---
 src/modules/systemd_failed_units.cpp | 34 ++++++++++++----------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/src/modules/systemd_failed_units.cpp b/src/modules/systemd_failed_units.cpp
index 600d0fb1..8d7e866f 100644
--- a/src/modules/systemd_failed_units.cpp
+++ b/src/modules/systemd_failed_units.cpp
@@ -18,8 +18,9 @@ namespace waybar::modules {
 SystemdFailedUnits::SystemdFailedUnits(const std::string& id, const Json::Value& config)
     : ALabel(config, "systemd-failed-units", id, "{nr_failed} failed", 1),
       hide_on_ok_(true),
-      tooltip_format_("System: {system_state}\nUser: {user_state}\nFailed units ({nr_failed}):\n"
-                       "{failed_units_list}"),
+      tooltip_format_(
+          "System: {system_state}\nUser: {user_state}\nFailed units ({nr_failed}):\n"
+          "{failed_units_list}"),
       tooltip_format_ok_("System: {system_state}\nUser: {user_state}"),
       tooltip_unit_format_("{name}: {description}"),
       update_pending_(false),
@@ -170,8 +171,7 @@ void SystemdFailedUnits::RequestFailedUnitsList() {
 
 auto SystemdFailedUnits::LoadFailedUnitsList(const char* kind,
                                              Glib::RefPtr<Gio::DBus::Proxy>& proxy,
-                                             const std::string& scope)
-    -> std::vector<FailedUnit> {
+                                             const std::string& scope) -> std::vector<FailedUnit> {
   // org.freedesktop.systemd1.Manager.ListUnits returns
   // (name, description, load_state, active_state, sub_state, followed, unit_path, job_id,
   //  job_type, job_path).
@@ -225,10 +225,8 @@ std::string SystemdFailedUnits::BuildTooltipFailedList() const {
           fmt::runtime(tooltip_unit_format_),
           fmt::arg("name", Glib::Markup::escape_text(unit.name).raw()),
           fmt::arg("description", Glib::Markup::escape_text(unit.description).raw()),
-          fmt::arg("load_state", unit.load_state),
-          fmt::arg("active_state", unit.active_state),
-          fmt::arg("sub_state", unit.sub_state),
-          fmt::arg("scope", unit.scope));
+          fmt::arg("load_state", unit.load_state), fmt::arg("active_state", unit.active_state),
+          fmt::arg("sub_state", unit.sub_state), fmt::arg("scope", unit.scope));
       if (!first) {
         list += "\n";
       }
@@ -280,21 +278,19 @@ auto SystemdFailedUnits::update() -> void {
 
   label_.set_markup(fmt::format(
       fmt::runtime(nr_failed_ == 0 ? format_ok_ : format_), fmt::arg("nr_failed", nr_failed_),
-      fmt::arg("nr_failed_system", nr_failed_system_),
-      fmt::arg("nr_failed_user", nr_failed_user_), fmt::arg("system_state", system_state_),
-      fmt::arg("user_state", user_state_), fmt::arg("overall_state", overall_state_)));
+      fmt::arg("nr_failed_system", nr_failed_system_), fmt::arg("nr_failed_user", nr_failed_user_),
+      fmt::arg("system_state", system_state_), fmt::arg("user_state", user_state_),
+      fmt::arg("overall_state", overall_state_)));
   if (tooltipEnabled()) {
     std::string failed_list = BuildTooltipFailedList();
     auto tooltip_template = overall_state_ == "ok" ? tooltip_format_ok_ : tooltip_format_;
     if (!tooltip_template.empty()) {
-      label_.set_tooltip_markup(
-          fmt::format(fmt::runtime(tooltip_template), fmt::arg("nr_failed", nr_failed_),
-                      fmt::arg("nr_failed_system", nr_failed_system_),
-                      fmt::arg("nr_failed_user", nr_failed_user_),
-                      fmt::arg("system_state", system_state_),
-                      fmt::arg("user_state", user_state_),
-                      fmt::arg("overall_state", overall_state_),
-                      fmt::arg("failed_units_list", failed_list)));
+      label_.set_tooltip_markup(fmt::format(
+          fmt::runtime(tooltip_template), fmt::arg("nr_failed", nr_failed_),
+          fmt::arg("nr_failed_system", nr_failed_system_),
+          fmt::arg("nr_failed_user", nr_failed_user_), fmt::arg("system_state", system_state_),
+          fmt::arg("user_state", user_state_), fmt::arg("overall_state", overall_state_),
+          fmt::arg("failed_units_list", failed_list)));
     } else {
       label_.set_tooltip_text("");
     }

From 215c952137f614e71b1485dfde2c3968477bef3d Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Thu, 19 Mar 2026 00:28:50 -0500
Subject: [PATCH 45/63] chore: remove heaptrack dump

Accidentally committed...

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 heaptrack.waybar.2711357.zst | Bin 12780 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 heaptrack.waybar.2711357.zst

diff --git a/heaptrack.waybar.2711357.zst b/heaptrack.waybar.2711357.zst
deleted file mode 100644
index 88921cba1ce1ab95825bb77f62a6f1a72e958a87..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12780
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


From 86234a8946787798ba39530ea3c74b017efe87d2 Mon Sep 17 00:00:00 2001
From: Austin Horstman <khaneliman12@gmail.com>
Date: Thu, 19 Mar 2026 00:29:01 -0500
Subject: [PATCH 46/63] feat: gitignore heaptrack dumps

Signed-off-by: Austin Horstman <khaneliman12@gmail.com>
---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index f42bf85e..f21700d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -52,3 +52,4 @@ result-*
 
 .ccls-cache
 _codeql_detected_source_root
+heaptrack*

From 95f9922ccc6e931d161b6d846f83b747f63b01af Mon Sep 17 00:00:00 2001
From: Viktar Lukashonak <myxabeer@gmail.com>
Date: Thu, 19 Mar 2026 11:03:08 +0300
Subject: [PATCH 47/63] cava bump

---
 nix/default.nix          | 6 +++---
 subprojects/libcava.wrap | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/nix/default.nix b/nix/default.nix
index 43b6e097..1850a414 100644
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -6,13 +6,13 @@
 }:
 let
   libcava = rec {
-    version = "0.10.7-beta";
+    version = "0.10.7";
     src = pkgs.fetchFromGitHub {
       owner = "LukashonakV";
       repo = "cava";
       # NOTE: Needs to match the cava.wrap
-      tag = "v${version}";
-      hash = "sha256-IX1B375gTwVDRjpRfwKGuzTAZOV2pgDWzUd4bW2cTDU=";
+      tag = "${version}";
+      hash = "sha256-zkyj1vBzHtoypX4Bxdh1Vmwh967DKKxN751v79hzmgQ=";
     };
   };
 in
diff --git a/subprojects/libcava.wrap b/subprojects/libcava.wrap
index 466e2262..d66d657b 100644
--- a/subprojects/libcava.wrap
+++ b/subprojects/libcava.wrap
@@ -4,9 +4,9 @@
 #depth = 1
 
 [wrap-file]
-directory = cava-0.10.7-beta
-source_url = https://github.com/LukashonakV/cava/archive/v0.10.7-beta.tar.gz
+directory = cava-0.10.7
+source_url = https://github.com/LukashonakV/cava/archive/0.10.7.tar.gz
 source_filename = cava-0.10.7.tar.gz
-source_hash = 8915d7214f2046554c158fe6f2ae518881dfb573e421ea848727be11a5dfa8c4
+source_hash = 50cc6413e9c96c503657f814744a2baf429a24ff9fed31a8343e0ed285269eff
 [provide]
 libcava = cava_dep

From 50c1431348ca544e47b6397e9891cd3bc7b33c7d Mon Sep 17 00:00:00 2001
From: Jakob Sjudin <jakob.sjudin@gmail.com>
Date: Thu, 19 Mar 2026 15:36:32 +0100
Subject: [PATCH 48/63] Add start-expanded option to group

---
 src/group.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/group.cpp b/src/group.cpp
index 51caf0e2..acd7bd42 100644
--- a/src/group.cpp
+++ b/src/group.cpp
@@ -64,11 +64,19 @@ Group::Group(const std::string& name, const std::string& id, const Json::Value&
                                     : true);
     click_to_reveal = drawer_config["click-to-reveal"].asBool();
 
+    const bool start_expanded =
+        (drawer_config["start-expanded"].isBool() ? drawer_config["start-expanded"].asBool()
+                                                  : false);
+
     auto transition_type = getPreferredTransitionType(vertical);
 
     revealer.set_transition_type(transition_type);
     revealer.set_transition_duration(transition_duration);
-    revealer.set_reveal_child(false);
+    revealer.set_reveal_child(start_expanded);
+
+    if (start_expanded) {
+      box.set_state_flags(Gtk::StateFlags::STATE_FLAG_PRELIGHT);
+    }
 
     revealer.get_style_context()->add_class("drawer");
 

From 83e1949dd8435d5f8991de366a8327a2a6e58786 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emir=20Baha=20Y=C4=B1ld=C4=B1r=C4=B1m?=
 <jayshozie@gmail.com>
Date: Thu, 19 Mar 2026 19:32:21 +0300
Subject: [PATCH 49/63] fix(hyprland/window): Fix segfault caused by
 use-after-free
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The window module registers itself with the Hyprland IPC singleton at
the start of its constructor, before calling update(). If update()
throws an exception (e.g. from an invalid format string), the object is
destroyed without the destructor running, leaving a dangling pointer in
the IPC callback list. When the IPC thread receives an event, it
attempts to call onEvent() on this invalid memory, causing a crash.

Moving the update() call before IPC registration ensures that any
initialization errors occur before the pointer is shared. If the
configuration is invalid, the module fails to construct and is
gracefully disabled by the factory without leaving a "landmine" in the
background IPC thread.

Fixes: #4923

Signed-off-by: Emir Baha Yıldırım <jayshozie@gmail.com>
---
 src/modules/hyprland/window.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/modules/hyprland/window.cpp b/src/modules/hyprland/window.cpp
index d3fe6edf..2e3e0bb9 100644
--- a/src/modules/hyprland/window.cpp
+++ b/src/modules/hyprland/window.cpp
@@ -19,20 +19,19 @@ std::shared_mutex windowIpcSmtx;
 
 Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
     : AAppIconLabel(config, "window", id, "{title}", 0, true), bar_(bar), m_ipc(IPC::inst()) {
-  std::unique_lock<std::shared_mutex> windowIpcUniqueLock(windowIpcSmtx);
-
   separateOutputs_ = config["separate-outputs"].asBool();
 
+  update();
+
   // register for hyprland ipc
+  std::unique_lock<std::shared_mutex> windowIpcUniqueLock(windowIpcSmtx);
   m_ipc.registerForIPC("activewindow", this);
   m_ipc.registerForIPC("closewindow", this);
   m_ipc.registerForIPC("movewindow", this);
   m_ipc.registerForIPC("changefloatingmode", this);
   m_ipc.registerForIPC("fullscreen", this);
-
   windowIpcUniqueLock.unlock();
 
-  update();
   dp.emit();
 }
 

From a05c7bc28ffaf889826102cb8e9ac75e9577b4ce Mon Sep 17 00:00:00 2001
From: ignormies <bryce.beagle@gmail.com>
Date: Thu, 19 Mar 2026 17:39:57 -0700
Subject: [PATCH 50/63] chore: Stop using deprecated/removed Nerdfonts
 codepoints
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These Nerdfonts codepoints were removed in [3.0.0](https://www.nerdfonts.com/releases#v3.0.0):

> **Breaking 2: Material Design Icons Codepoints**
>
> The old Material Design Icon codepoints are finally dropped. Due to an historic mistake we placed them in between some asiatic glyphs, breaking that script. Since v2.3.0 the (updated and expanded) Material Design Icons have new codepoints in the 5 digit region.
>
> - Dropped codepoints `F500`… and class names `nf-mdi-*`
> - New codepoints `F0001`… and class names `nf-md-*`
> - The whole discussions are here: https://github.com/ryanoasis/nerd-fonts/issues/365
> - A translation table is available here: https://github.com/ryanoasis/nerd-fonts/issues/1059#issuecomment-1404891287
> - There are tools out there that probably can update your configuration.

For the majority of the removed symbols, it was as easy as finding the
replacement with the exact same name. For example, `f76b` (`nf-mdi-format_header_2`)
became `f026c` (`nf-md-format_header_2`).

There was one symbol that was completely removed (it was removed from
Material Design): `f5fc` (`nf-mdi-camcorder_box`). I have substituted it
with `f03d` (`nf-fa-video_camera`) which is not Material Design, but the
closest icon I could find.

Here's some example output from [nerdfix](https://github.com/loichyan/nerdfix)
```
╭─(ignormies)(~/g/fork-waybar)  removed-nerdfonts-codepoints
╰──▪ nix-shell -p nerdfix --run "nerdfix check resources/config.jsonc"
 INFO Check input from 'resources/config.jsonc'
  ☞ Found obsolete icon U+F76B
     ╭─[resources/config.jsonc:131:27]
 130 │         "format": "{temperatureC}°C {icon}",
 131 │         "format-icons": ["", "", ""]
     ·                           ┬
     ·                           ╰── Icon 'mdi-format_header_2' is marked as obsolete
 132 │     },
     ╰────
  help: You could replace it with:
          1. 󰉬 U+F026C md-format_header_2
          2. 󰉫 U+F026B md-format_header_1
          3. 󰉭 U+F026D md-format_header_3
          4. 󰉮 U+F026E md-format_header_4

  ☞ Found obsolete icon U+F769
     ╭─[resources/config.jsonc:131:41]
 130 │         "format": "{temperatureC}°C {icon}",
 131 │         "format-icons": ["", "", ""]
     ·                                     ┬
     ·                                     ╰── Icon 'mdi-format_float_right' is marked as obsolete
 132 │     },
     ╰────
  help: You could replace it with:
          1. 󰉪 U+F026A md-format_float_right
          2. 󰉨 U+F0268 md-format_float_left
          3. 󰉩 U+F0269 md-format_float_none
          4. 󰉣 U+F0263 md-format_align_right

  ☞ Found obsolete icon U+F5E7
     ╭─[resources/config.jsonc:146:41]
 145 │         "format-full": "{capacity}% {icon}",
 146 │         "format-charging": "{capacity}% ",
     ·                                         ┬
     ·                                         ╰── Icon 'mdi-cached' is marked as obsolete
 147 │         "format-plugged": "{capacity}% ",
     ╰────
  help: You could replace it with:
          1. 󰃨 U+F00E8 md-cached

  ☞ Found obsolete icon U+F796
     ╭─[resources/config.jsonc:170:45]
 169 │         "format-wifi": "{essid} ({signalStrength}%) ",
 170 │         "format-ethernet": "{ipaddr}/{cidr} ",
     ·                                             ┬
     ·                                             ╰── Icon 'mdi-gamepad_variant' is marked as obsolete
 171 │         "tooltip-format": "{ifname} via {gwaddr} ",
     ╰────
  help: You could replace it with:
          1. 󰊗 U+F0297 md-gamepad_variant
          2. 󰺷 U+F0EB7 md-gamepad_variant_outline
          3. 󰑢 U+F0462 md-road_variant
          4. 󰉜 U+F025C md-food_variant

  ☞ Found obsolete icon U+F796
     ╭─[resources/config.jsonc:171:50]
 170 │         "format-ethernet": "{ipaddr}/{cidr} ",
 171 │         "tooltip-format": "{ifname} via {gwaddr} ",
     ·                                                  ┬
     ·                                                  ╰── Icon 'mdi-gamepad_variant' is marked as obsolete
 172 │         "format-linked": "{ifname} (No IP) ",
     ╰────
  help: You could replace it with:
          1. 󰊗 U+F0297 md-gamepad_variant
          2. 󰺷 U+F0EB7 md-gamepad_variant_outline
          3. 󰑢 U+F0462 md-road_variant
          4. 󰉜 U+F025C md-food_variant

  ☞ Found obsolete icon U+F796
     ╭─[resources/config.jsonc:172:44]
 171 │         "tooltip-format": "{ifname} via {gwaddr} ",
 172 │         "format-linked": "{ifname} (No IP) ",
     ·                                            ┬
     ·                                            ╰── Icon 'mdi-gamepad_variant' is marked as obsolete
 173 │         "format-disconnected": "Disconnected ⚠",
     ╰────
  help: You could replace it with:
          1. 󰊗 U+F0297 md-gamepad_variant
          2. 󰺷 U+F0EB7 md-gamepad_variant_outline
          3. 󰑢 U+F0462 md-road_variant
          4. 󰉜 U+F025C md-food_variant

  ☞ Found obsolete icon U+F6A9
     ╭─[resources/config.jsonc:180:36]
 179 │         "format-bluetooth": "{volume}% {icon} {format_source}",
 180 │         "format-bluetooth-muted": " {icon} {format_source}",
     ·                                    ┬
     ·                                    ╰── Icon 'mdi-cup' is marked as obsolete
 181 │         "format-muted": " {format_source}",
     ╰────
  help: You could replace it with:
          1. 󰆪 U+F01AA md-cup

  ☞ Found obsolete icon U+F6A9
     ╭─[resources/config.jsonc:181:26]
 180 │         "format-bluetooth-muted": " {icon} {format_source}",
 181 │         "format-muted": " {format_source}",
     ·                          ┬
     ·                          ╰── Icon 'mdi-cup' is marked as obsolete
 182 │         "format-source": "{volume}% ",
     ╰────
  help: You could replace it with:
          1. 󰆪 U+F01AA md-cup

  ☞ Found obsolete icon U+F590
     ╭─[resources/config.jsonc:186:28]
 185 │             "headphone": "",
 186 │             "hands-free": "",
     ·                            ┬
     ·                            ╰── Icon 'mdi-battery_unknown' is marked as obsolete
 187 │             "headset": "",
     ╰────
  help: You could replace it with:
          1. 󰂑 U+F0091 md-battery_unknown
          2. 󰥊 U+F094A md-battery_unknown_bluetooth
          3. 󱟞 U+F17DE md-battery_arrow_down
          4. 󰝐 U+F0750 md-microsoft_xbox_controller_battery_unknown

  ☞ Found obsolete icon U+F590
     ╭─[resources/config.jsonc:187:25]
 186 │             "hands-free": "",
 187 │             "headset": "",
     ·                         ┬
     ·                         ╰── Icon 'mdi-battery_unknown' is marked as obsolete
 188 │             "phone": "",
     ╰────
  help: You could replace it with:
          1. 󰂑 U+F0091 md-battery_unknown
          2. 󰥊 U+F094A md-battery_unknown_bluetooth
          3. 󱟞 U+F17DE md-battery_arrow_down
          4. 󰝐 U+F0750 md-microsoft_xbox_controller_battery_unknown
```
---
 include/modules/gamemode.hpp |  2 +-
 man/waybar-clock.5.scd       |  4 ++--
 man/waybar-gamemode.5.scd    |  4 ++--
 man/waybar-pulseaudio.5.scd  |  4 ++--
 man/waybar-river-mode.5.scd  |  2 +-
 man/waybar-sway-mode.5.scd   |  2 +-
 man/waybar-wireplumber.5.scd |  2 +-
 resources/config.jsonc       | 18 +++++++++---------
 8 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/include/modules/gamemode.hpp b/include/modules/gamemode.hpp
index f63861a3..89f66272 100644
--- a/include/modules/gamemode.hpp
+++ b/include/modules/gamemode.hpp
@@ -26,7 +26,7 @@ class Gamemode : public AModule {
   const std::string DEFAULT_FORMAT = "{glyph}";
   const std::string DEFAULT_FORMAT_ALT = "{glyph} {count}";
   const std::string DEFAULT_TOOLTIP_FORMAT = "Games running: {count}";
-  const std::string DEFAULT_GLYPH = "";
+  const std::string DEFAULT_GLYPH = "󰊴";
 
   void appear(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name,
               const Glib::ustring& name_owner);
diff --git a/man/waybar-clock.5.scd b/man/waybar-clock.5.scd
index 5c5509f6..1b13dcb7 100644
--- a/man/waybar-clock.5.scd
+++ b/man/waybar-clock.5.scd
@@ -204,7 +204,7 @@ View all valid format options in *strftime(3)* or have a look https://en.cpprefe
 ```
 "clock": {
 	"format": "{:%H:%M}  ",
-	"format-alt": "{:%A, %B %d, %Y (%R)}  ",
+	"format-alt": "{:%A, %B %d, %Y (%R)} 󰃰 ",
 	"tooltip-format": "<tt><small>{calendar}</small></tt>",
 	"calendar": {
 		"mode"          : "year",
@@ -299,7 +299,7 @@ Example of working config
 ```
 "clock": {
 	"format": "{:%H:%M}  ",
-	"format-alt": "{:%A, %B %d, %Y (%R)}  ",
+	"format-alt": "{:%A, %B %d, %Y (%R)} 󰃰 ",
 	"tooltip-format": "\n<span size='9pt' font='WenQuanYi Zen Hei Mono'>{calendar}</span>",
 	"calendar": {
 		"mode"          : "year",
diff --git a/man/waybar-gamemode.5.scd b/man/waybar-gamemode.5.scd
index a6ca9af0..bb82e0aa 100644
--- a/man/waybar-gamemode.5.scd
+++ b/man/waybar-gamemode.5.scd
@@ -43,7 +43,7 @@ Feral Gamemode optimizations.
 
 *glyph*: ++
 	typeof: string ++
-	default:  ++
+	default: 󰊴 ++
 	The string icon to display. Only visible if *use-icon* is set to false.
 
 *icon-name*: ++
@@ -82,7 +82,7 @@ Feral Gamemode optimizations.
 "gamemode": {
 	"format": "{glyph}",
 	"format-alt": "{glyph} {count}",
-	"glyph": "",
+	"glyph": "󰊴",
 	"hide-not-running": true,
 	"use-icon": true,
 	"icon-name": "input-gaming-symbolic",
diff --git a/man/waybar-pulseaudio.5.scd b/man/waybar-pulseaudio.5.scd
index f555fd4d..a52d5b3e 100644
--- a/man/waybar-pulseaudio.5.scd
+++ b/man/waybar-pulseaudio.5.scd
@@ -178,8 +178,8 @@ to be selected when the corresponding audio device is muted. This applies to *de
 		"alsa_output.pci-0000_00_1f.3.analog-stereo": "",
 		"alsa_output.pci-0000_00_1f.3.analog-stereo-muted": "",
 		"headphone": "",
-		"hands-free": "",
-		"headset": "",
+		"hands-free": "󰂑",
+		"headset": "󰂑",
 		"phone": "",
 		"phone-muted": "",
 		"portable": "",
diff --git a/man/waybar-river-mode.5.scd b/man/waybar-river-mode.5.scd
index 5837411d..ac209f2c 100644
--- a/man/waybar-river-mode.5.scd
+++ b/man/waybar-river-mode.5.scd
@@ -87,7 +87,7 @@ Addressed by *river/mode*
 
 ```
 "river/mode": {
-	"format": " {}"
+	"format": " {}"
 }
 ```
 
diff --git a/man/waybar-sway-mode.5.scd b/man/waybar-sway-mode.5.scd
index 52827376..2c5ba7e6 100644
--- a/man/waybar-sway-mode.5.scd
+++ b/man/waybar-sway-mode.5.scd
@@ -92,7 +92,7 @@ Addressed by *sway/mode*
 
 ```
 "sway/mode": {
-	"format": " {}",
+	"format": " {}",
 	"max-length": 50
 }
 ```
diff --git a/man/waybar-wireplumber.5.scd b/man/waybar-wireplumber.5.scd
index ae78f184..8d97d7af 100644
--- a/man/waybar-wireplumber.5.scd
+++ b/man/waybar-wireplumber.5.scd
@@ -128,7 +128,7 @@ The *wireplumber* module displays the current volume reported by WirePlumber.
 ```
 "wireplumber#sink": {
     "format": "{volume}% {icon}",
-    "format-muted": "",
+    "format-muted": "󰅶",
     "format-icons": ["", "", ""],
     "on-click": "helvum",
     "on-click-right": "wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle",
diff --git a/resources/config.jsonc b/resources/config.jsonc
index 67d5ff5b..9ba8b97a 100644
--- a/resources/config.jsonc
+++ b/resources/config.jsonc
@@ -128,7 +128,7 @@
         "critical-threshold": 80,
         // "format-critical": "{temperatureC}°C {icon}",
         "format": "{temperatureC}°C {icon}",
-        "format-icons": ["", "", ""]
+        "format-icons": ["󰉬", "", "󰉪"]
     },
     "backlight": {
         // "device": "acpi_video1",
@@ -143,7 +143,7 @@
         },
         "format": "{capacity}% {icon}",
         "format-full": "{capacity}% {icon}",
-        "format-charging": "{capacity}% ",
+        "format-charging": "{capacity}% 󰃨",
         "format-plugged": "{capacity}% ",
         "format-alt": "{time} {icon}",
         // "format-good": "", // An empty format will hide the module
@@ -167,9 +167,9 @@
     "network": {
         // "interface": "wlp2*", // (Optional) To force the use of this interface
         "format-wifi": "{essid} ({signalStrength}%) ",
-        "format-ethernet": "{ipaddr}/{cidr} ",
-        "tooltip-format": "{ifname} via {gwaddr} ",
-        "format-linked": "{ifname} (No IP) ",
+        "format-ethernet": "{ipaddr}/{cidr} 󰊗",
+        "tooltip-format": "{ifname} via {gwaddr} 󰊗",
+        "format-linked": "{ifname} (No IP) 󰊗",
         "format-disconnected": "Disconnected ⚠",
         "format-alt": "{ifname}: {ipaddr}/{cidr}"
     },
@@ -177,14 +177,14 @@
         // "scroll-step": 1, // %, can be a float
         "format": "{volume}% {icon} {format_source}",
         "format-bluetooth": "{volume}% {icon} {format_source}",
-        "format-bluetooth-muted": " {icon} {format_source}",
-        "format-muted": " {format_source}",
+        "format-bluetooth-muted": "󰅶 {icon} {format_source}",
+        "format-muted": "󰅶 {format_source}",
         "format-source": "{volume}% ",
         "format-source-muted": "",
         "format-icons": {
             "headphone": "",
-            "hands-free": "",
-            "headset": "",
+            "hands-free": "󰂑",
+            "headset": "󰂑",
             "phone": "",
             "portable": "",
             "car": "",

From 6afe10864279dd09a66c13d222f61e9d1bcaa260 Mon Sep 17 00:00:00 2001
From: Jakob Sjudin <jakob.sjudin@gmail.com>
Date: Fri, 20 Mar 2026 08:15:23 +0100
Subject: [PATCH 51/63] Update manpages

---
 man/waybar.5.scd.in | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/man/waybar.5.scd.in b/man/waybar.5.scd.in
index 624798ed..8b923eef 100644
--- a/man/waybar.5.scd.in
+++ b/man/waybar.5.scd.in
@@ -363,6 +363,11 @@ A group may hide all but one element, showing them only on mouse hover. In order
 	default: false ++
 	Whether left click should reveal the content rather than mouse over. Note that grouped modules may still process their own on-click events.
 
+*start-expanded*: ++
+	typeof: bool ++
+	default: false ++
+	Defines whether the drawer should initialize in an expanded state.
+
 *transition-left-to-right*: ++
 	typeof: bool ++
 	default: true ++

From c0c1a4223ad06dc7690e15825aab56a409e37498 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Stefan=20Gr=C3=BCndel?= <stefan.gruendel@gmail.com>
Date: Sat, 21 Mar 2026 13:17:06 +0100
Subject: [PATCH 52/63] Fix network bandwidth rate calculation for early
 updates

---
 include/modules/network.hpp |  1 +
 src/modules/network.cpp     | 43 +++++++++++++++++++++----------------
 2 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/include/modules/network.hpp b/include/modules/network.hpp
index 4abe26bd..3bc43b23 100644
--- a/include/modules/network.hpp
+++ b/include/modules/network.hpp
@@ -70,6 +70,7 @@ class Network : public ALabel {
 
   unsigned long long bandwidth_down_total_{0};
   unsigned long long bandwidth_up_total_{0};
+  std::chrono::steady_clock::time_point bandwidth_last_sample_time_;
 
   std::string state_;
   std::string essid_;
diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index a4f2bcc2..ede4b988 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -105,6 +105,7 @@ waybar::modules::Network::Network(const std::string& id, const Json::Value& conf
     bandwidth_down_total_ = 0;
     bandwidth_up_total_ = 0;
   }
+  bandwidth_last_sample_time_ = std::chrono::steady_clock::now();
 
   if (!config_["interface"].isString()) {
     // "interface" isn't configured, then try to guess the external
@@ -277,6 +278,12 @@ const std::string waybar::modules::Network::getNetworkState() const {
 auto waybar::modules::Network::update() -> void {
   std::lock_guard<std::mutex> lock(mutex_);
   std::string tooltip_format;
+  auto now = std::chrono::steady_clock::now();
+  auto elapsed_seconds = std::chrono::duration<double>(now - bandwidth_last_sample_time_).count();
+  if (elapsed_seconds <= 0.0) {
+    elapsed_seconds = std::chrono::duration<double>(interval_).count();
+  }
+  bandwidth_last_sample_time_ = now;
 
   auto bandwidth = readBandwidthUsage();
   auto bandwidth_down = 0ull;
@@ -336,22 +343,22 @@ auto waybar::modules::Network::update() -> void {
       fmt::arg("cidr6", cidr6_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
       fmt::arg("icon", getIcon(signal_strength_, state_)),
       fmt::arg("bandwidthDownBits",
-               pow_format(bandwidth_down * 8ull / (interval_.count() / 1000.0), "b/s")),
+             pow_format(bandwidth_down * 8ull / elapsed_seconds, "b/s")),
       fmt::arg("bandwidthUpBits",
-               pow_format(bandwidth_up * 8ull / (interval_.count() / 1000.0), "b/s")),
+             pow_format(bandwidth_up * 8ull / elapsed_seconds, "b/s")),
       fmt::arg(
           "bandwidthTotalBits",
-          pow_format((bandwidth_up + bandwidth_down) * 8ull / (interval_.count() / 1000.0), "b/s")),
+          pow_format((bandwidth_up + bandwidth_down) * 8ull / elapsed_seconds, "b/s")),
       fmt::arg("bandwidthDownOctets",
-               pow_format(bandwidth_down / (interval_.count() / 1000.0), "o/s")),
-      fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / (interval_.count() / 1000.0), "o/s")),
+             pow_format(bandwidth_down / elapsed_seconds, "o/s")),
+        fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / elapsed_seconds, "o/s")),
       fmt::arg("bandwidthTotalOctets",
-               pow_format((bandwidth_up + bandwidth_down) / (interval_.count() / 1000.0), "o/s")),
+             pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "o/s")),
       fmt::arg("bandwidthDownBytes",
-               pow_format(bandwidth_down / (interval_.count() / 1000.0), "B/s")),
-      fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / (interval_.count() / 1000.0), "B/s")),
+             pow_format(bandwidth_down / elapsed_seconds, "B/s")),
+        fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / elapsed_seconds, "B/s")),
       fmt::arg("bandwidthTotalBytes",
-               pow_format((bandwidth_up + bandwidth_down) / (interval_.count() / 1000.0), "B/s")));
+             pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "B/s")));
   if (text.compare(label_.get_label()) != 0) {
     label_.set_markup(text);
     if (text.empty()) {
@@ -374,26 +381,26 @@ auto waybar::modules::Network::update() -> void {
           fmt::arg("cidr6", cidr6_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
           fmt::arg("icon", getIcon(signal_strength_, state_)),
           fmt::arg("bandwidthDownBits",
-                   pow_format(bandwidth_down * 8ull / (interval_.count() / 1000.0), "b/s")),
+                 pow_format(bandwidth_down * 8ull / elapsed_seconds, "b/s")),
           fmt::arg("bandwidthUpBits",
-                   pow_format(bandwidth_up * 8ull / (interval_.count() / 1000.0), "b/s")),
+                 pow_format(bandwidth_up * 8ull / elapsed_seconds, "b/s")),
           fmt::arg("bandwidthTotalBits",
-                   pow_format((bandwidth_up + bandwidth_down) * 8ull / (interval_.count() / 1000.0),
+                 pow_format((bandwidth_up + bandwidth_down) * 8ull / elapsed_seconds,
                               "b/s")),
           fmt::arg("bandwidthDownOctets",
-                   pow_format(bandwidth_down / (interval_.count() / 1000.0), "o/s")),
+                 pow_format(bandwidth_down / elapsed_seconds, "o/s")),
           fmt::arg("bandwidthUpOctets",
-                   pow_format(bandwidth_up / (interval_.count() / 1000.0), "o/s")),
+                 pow_format(bandwidth_up / elapsed_seconds, "o/s")),
           fmt::arg(
               "bandwidthTotalOctets",
-              pow_format((bandwidth_up + bandwidth_down) / (interval_.count() / 1000.0), "o/s")),
+              pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "o/s")),
           fmt::arg("bandwidthDownBytes",
-                   pow_format(bandwidth_down / (interval_.count() / 1000.0), "B/s")),
+                 pow_format(bandwidth_down / elapsed_seconds, "B/s")),
           fmt::arg("bandwidthUpBytes",
-                   pow_format(bandwidth_up / (interval_.count() / 1000.0), "B/s")),
+                 pow_format(bandwidth_up / elapsed_seconds, "B/s")),
           fmt::arg(
               "bandwidthTotalBytes",
-              pow_format((bandwidth_up + bandwidth_down) / (interval_.count() / 1000.0), "B/s")));
+              pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "B/s")));
       if (label_.get_tooltip_text() != tooltip_text) {
         label_.set_tooltip_markup(tooltip_text);
       }

From dc31db6d0c79e30fe5c5f219d8c53f1d4bfdb74c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Stefan=20Gr=C3=BCndel?= <stefan.gruendel@gmail.com>
Date: Sat, 21 Mar 2026 18:38:33 +0100
Subject: [PATCH 53/63] fix: linting error

---
 src/modules/network.cpp | 56 ++++++++++++++++-------------------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index ede4b988..31092133 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -342,23 +342,18 @@ auto waybar::modules::Network::update() -> void {
       fmt::arg("ipaddr", final_ipaddr_), fmt::arg("gwaddr", gwaddr_), fmt::arg("cidr", cidr_),
       fmt::arg("cidr6", cidr6_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
       fmt::arg("icon", getIcon(signal_strength_, state_)),
-      fmt::arg("bandwidthDownBits",
-             pow_format(bandwidth_down * 8ull / elapsed_seconds, "b/s")),
-      fmt::arg("bandwidthUpBits",
-             pow_format(bandwidth_up * 8ull / elapsed_seconds, "b/s")),
-      fmt::arg(
-          "bandwidthTotalBits",
-          pow_format((bandwidth_up + bandwidth_down) * 8ull / elapsed_seconds, "b/s")),
-      fmt::arg("bandwidthDownOctets",
-             pow_format(bandwidth_down / elapsed_seconds, "o/s")),
-        fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / elapsed_seconds, "o/s")),
+      fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / elapsed_seconds, "b/s")),
+      fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / elapsed_seconds, "b/s")),
+      fmt::arg("bandwidthTotalBits",
+               pow_format((bandwidth_up + bandwidth_down) * 8ull / elapsed_seconds, "b/s")),
+      fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / elapsed_seconds, "o/s")),
+      fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / elapsed_seconds, "o/s")),
       fmt::arg("bandwidthTotalOctets",
-             pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "o/s")),
-      fmt::arg("bandwidthDownBytes",
-             pow_format(bandwidth_down / elapsed_seconds, "B/s")),
-        fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / elapsed_seconds, "B/s")),
+               pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "o/s")),
+      fmt::arg("bandwidthDownBytes", pow_format(bandwidth_down / elapsed_seconds, "B/s")),
+      fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / elapsed_seconds, "B/s")),
       fmt::arg("bandwidthTotalBytes",
-             pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "B/s")));
+               pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "B/s")));
   if (text.compare(label_.get_label()) != 0) {
     label_.set_markup(text);
     if (text.empty()) {
@@ -380,27 +375,18 @@ auto waybar::modules::Network::update() -> void {
           fmt::arg("ipaddr", final_ipaddr_), fmt::arg("gwaddr", gwaddr_), fmt::arg("cidr", cidr_),
           fmt::arg("cidr6", cidr6_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
           fmt::arg("icon", getIcon(signal_strength_, state_)),
-          fmt::arg("bandwidthDownBits",
-                 pow_format(bandwidth_down * 8ull / elapsed_seconds, "b/s")),
-          fmt::arg("bandwidthUpBits",
-                 pow_format(bandwidth_up * 8ull / elapsed_seconds, "b/s")),
+          fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / elapsed_seconds, "b/s")),
+          fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / elapsed_seconds, "b/s")),
           fmt::arg("bandwidthTotalBits",
-                 pow_format((bandwidth_up + bandwidth_down) * 8ull / elapsed_seconds,
-                              "b/s")),
-          fmt::arg("bandwidthDownOctets",
-                 pow_format(bandwidth_down / elapsed_seconds, "o/s")),
-          fmt::arg("bandwidthUpOctets",
-                 pow_format(bandwidth_up / elapsed_seconds, "o/s")),
-          fmt::arg(
-              "bandwidthTotalOctets",
-              pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "o/s")),
-          fmt::arg("bandwidthDownBytes",
-                 pow_format(bandwidth_down / elapsed_seconds, "B/s")),
-          fmt::arg("bandwidthUpBytes",
-                 pow_format(bandwidth_up / elapsed_seconds, "B/s")),
-          fmt::arg(
-              "bandwidthTotalBytes",
-              pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "B/s")));
+                   pow_format((bandwidth_up + bandwidth_down) * 8ull / elapsed_seconds, "b/s")),
+          fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / elapsed_seconds, "o/s")),
+          fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / elapsed_seconds, "o/s")),
+          fmt::arg("bandwidthTotalOctets",
+                   pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "o/s")),
+          fmt::arg("bandwidthDownBytes", pow_format(bandwidth_down / elapsed_seconds, "B/s")),
+          fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / elapsed_seconds, "B/s")),
+          fmt::arg("bandwidthTotalBytes",
+                   pow_format((bandwidth_up + bandwidth_down) / elapsed_seconds, "B/s")));
       if (label_.get_tooltip_text() != tooltip_text) {
         label_.set_tooltip_markup(tooltip_text);
       }

From 60c57b7195dabc750dfe1faca01ad936961b120b Mon Sep 17 00:00:00 2001
From: Visal Vijay <visalvijay83@gmail.com>
Date: Sun, 22 Mar 2026 11:40:44 +0530
Subject: [PATCH 54/63] clarify logical condition in wlr taskbar module

---
 src/modules/wlr/taskbar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/modules/wlr/taskbar.cpp b/src/modules/wlr/taskbar.cpp
index 2aef0ae3..bde90910 100644
--- a/src/modules/wlr/taskbar.cpp
+++ b/src/modules/wlr/taskbar.cpp
@@ -198,7 +198,7 @@ void Task::handle_title(const char* title) {
   title_ = title;
   hide_if_ignored();
 
-  if (!with_icon_ && !with_name_ || app_info_) {
+  if ((!with_icon_ && !with_name_) || app_info_) {
     return;
   }
 

From 1aa32def3bff7a1af47f20440f443d53a60a9c46 Mon Sep 17 00:00:00 2001
From: Visal Vijay <visalvijay83@gmail.com>
Date: Sun, 22 Mar 2026 15:41:50 +0530
Subject: [PATCH 55/63] fix: prevent resource leak when rebinding Wayland
 globals

---
 src/client.cpp | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/client.cpp b/src/client.cpp
index 103b093f..1da3ffcb 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -19,11 +19,26 @@ waybar::Client* waybar::Client::inst() {
 void waybar::Client::handleGlobal(void* data, struct wl_registry* registry, uint32_t name,
                                   const char* interface, uint32_t version) {
   auto* client = static_cast<Client*>(data);
+
   if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 &&
       version >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) {
-    client->xdg_output_manager = static_cast<struct zxdg_output_manager_v1*>(wl_registry_bind(
-        registry, name, &zxdg_output_manager_v1_interface, ZXDG_OUTPUT_V1_NAME_SINCE_VERSION));
+
+    if (client->xdg_output_manager != nullptr) {
+      zxdg_output_manager_v1_destroy(client->xdg_output_manager);
+      client->xdg_output_manager = nullptr;
+    }
+
+    client->xdg_output_manager = static_cast<struct zxdg_output_manager_v1*>(
+        wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface,
+                         ZXDG_OUTPUT_V1_NAME_SINCE_VERSION));
+
   } else if (strcmp(interface, zwp_idle_inhibit_manager_v1_interface.name) == 0) {
+
+    if (client->idle_inhibit_manager != nullptr) {
+      zwp_idle_inhibit_manager_v1_destroy(client->idle_inhibit_manager);
+      client->idle_inhibit_manager = nullptr;   
+    }
+
     client->idle_inhibit_manager = static_cast<struct zwp_idle_inhibit_manager_v1*>(
         wl_registry_bind(registry, name, &zwp_idle_inhibit_manager_v1_interface, 1));
   }

From b64265bdf71eba390b0dbebcea674bfa5434c231 Mon Sep 17 00:00:00 2001
From: Greg Darke <greg@tsukasa.au>
Date: Mon, 23 Mar 2026 14:33:51 +1100
Subject: [PATCH 56/63] Network: Fix default interface selection.

When an interface is not specified for the network module, we parse the
routing table to look for default routes.

We have defined a default route to:
- have a gateway specified, and
- have no destination specified, or have an all-zero destination.

Previous versions of Waybar had the second condition inverted,
causing it to incorrectly pick interfaces are used to route a
subnet/single host.

For example, with the following routing table, we should pick `eth0` to
show information about, not `wg0`.

```
ip -4 route
default via 192.168.252.1 dev eth0 proto dhcp src 192.168.252.200 metric 100
192.168.252.0/24 dev eth0 proto kernel scope link src 192.168.252.200 metric 100
192.168.2.254 via 192.168.1.1 dev wg0 proto static metric 50
192.168.1.0/24 dev wg0 proto static scope link metric 50
192.168.1.0/24 dev wg0 proto kernel scope link src 192.168.1.254 metric 50
```
---
 src/modules/network.cpp | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/modules/network.cpp b/src/modules/network.cpp
index a4f2bcc2..6c31324a 100644
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@@ -744,16 +744,20 @@ int waybar::modules::Network::handleEvents(struct nl_msg* msg, void* data) {
             /* The destination address.
              * Should be either missing, or maybe all 0s.  Accept both.
              */
-            const uint32_t nr_zeroes = (family == AF_INET) ? 4 : 16;
-            unsigned char c = 0;
-            size_t dstlen = RTA_PAYLOAD(attr);
-            if (dstlen != nr_zeroes) {
-              break;
+            auto* dest = (const unsigned char*)RTA_DATA(attr);
+            size_t dest_size = RTA_PAYLOAD(attr);
+            for (size_t i = 0; i < dest_size; ++i) {
+              if (dest[i] != 0) {
+                has_destination = true;
+                break;
+              }
             }
-            for (uint32_t i = 0; i < dstlen; i += 1) {
-              c |= *((unsigned char*)RTA_DATA(attr) + i);
+
+            if (rtm->rtm_dst_len != 0) {
+              // We have found a destination like 0.0.0.0/24, this is not a
+              // default gateway route.
+              has_destination = true;
             }
-            has_destination = (c == 0);
             break;
           }
           case RTA_OIF:

From e55bff662e18cc853d6df5c820d05e3823f00ef1 Mon Sep 17 00:00:00 2001
From: Visal Vijay <visalvijay83@gmail.com>
Date: Wed, 25 Mar 2026 21:45:14 +0530
Subject: [PATCH 57/63] Remove unnecessary g_strdup in GTK callback

---
 src/ALabel.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/ALabel.cpp b/src/ALabel.cpp
index b23926d8..795f87f1 100644
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@@ -116,9 +116,8 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
         }
         submenus_[key] = GTK_MENU_ITEM(item);
         menuActionsMap_[key] = it->asString();
-        g_signal_connect(submenus_[key], "activate",
-                 G_CALLBACK(handleGtkMenuEvent),
-                 (gpointer)g_strdup(menuActionsMap_[key].c_str()));          
+        g_signal_connect(submenus_[key], "activate", G_CALLBACK(handleGtkMenuEvent),
+                         (gpointer)menuActionsMap_[key].c_str());
       }
       g_object_unref(builder);
     } catch (std::runtime_error& e) {

From 3b512d1a2cfcfcb454616e3e3988fab34b1ac3c4 Mon Sep 17 00:00:00 2001
From: Keepo <bexel96@gmail.com>
Date: Sat, 28 Mar 2026 21:10:15 -0400
Subject: [PATCH 58/63] feat(client): add support for 8-bit hex color codes in
 CSS

This allows users to use #RRGGBBAA format in their style.css.
The client now detects 8-bit hex codes, transforms them into
GTK-compatible rgba() syntax, and loads the modified data
into the CSS provider.

- Added utility to detect 8-bit hex patterns.
- Added transformation logic to convert hex alpha to decimal.
- Intercepted CSS loading in Client::setupCss to handle the conversion.
---
 include/util/hex_checker.hpp        | 17 ++++++++++++
 meson.build                         |  4 ++-
 src/client.cpp                      | 22 +++++++++-------
 src/util/has_8bit_hex.cpp           | 15 +++++++++++
 src/util/transform_8bit_to_rgba.cpp | 41 +++++++++++++++++++++++++++++
 5 files changed, 88 insertions(+), 11 deletions(-)
 create mode 100644 include/util/hex_checker.hpp
 create mode 100644 src/util/has_8bit_hex.cpp
 create mode 100644 src/util/transform_8bit_to_rgba.cpp

diff --git a/include/util/hex_checker.hpp b/include/util/hex_checker.hpp
new file mode 100644
index 00000000..5e742436
--- /dev/null
+++ b/include/util/hex_checker.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <string>
+
+/**
+ * Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
+ * and returns true if found, or false if not found.
+ */
+
+bool has_8bit_hex(std::string file_path);
+
+/**
+ * Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
+ * and transforms them into GTK-compatible rgba() syntax.
+ */
+
+std::string transform_8bit_to_hex(std::string file_path);
diff --git a/meson.build b/meson.build
index db9407eb..b9df3f80 100644
--- a/meson.build
+++ b/meson.build
@@ -185,7 +185,9 @@ src_files = files(
     'src/util/gtk_icon.cpp',
     'src/util/icon_loader.cpp',
     'src/util/regex_collection.cpp',
-    'src/util/css_reload_helper.cpp'
+    'src/util/css_reload_helper.cpp',
+    'src/util/has_8bit_hex.cpp',
+    'src/util/transform_8bit_to_rgba.cpp'
 )
 
 man_files = files(
diff --git a/src/client.cpp b/src/client.cpp
index 1da3ffcb..178552a4 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -10,6 +10,7 @@
 #include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "util/clara.hpp"
 #include "util/format.hpp"
+#include "util/hex_checker.hpp"
 
 waybar::Client* waybar::Client::inst() {
   static auto* c = new Client();
@@ -22,21 +23,18 @@ void waybar::Client::handleGlobal(void* data, struct wl_registry* registry, uint
 
   if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 &&
       version >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) {
-
     if (client->xdg_output_manager != nullptr) {
       zxdg_output_manager_v1_destroy(client->xdg_output_manager);
       client->xdg_output_manager = nullptr;
     }
 
-    client->xdg_output_manager = static_cast<struct zxdg_output_manager_v1*>(
-        wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface,
-                         ZXDG_OUTPUT_V1_NAME_SINCE_VERSION));
+    client->xdg_output_manager = static_cast<struct zxdg_output_manager_v1*>(wl_registry_bind(
+        registry, name, &zxdg_output_manager_v1_interface, ZXDG_OUTPUT_V1_NAME_SINCE_VERSION));
 
   } else if (strcmp(interface, zwp_idle_inhibit_manager_v1_interface.name) == 0) {
-
     if (client->idle_inhibit_manager != nullptr) {
       zwp_idle_inhibit_manager_v1_destroy(client->idle_inhibit_manager);
-      client->idle_inhibit_manager = nullptr;   
+      client->idle_inhibit_manager = nullptr;
     }
 
     client->idle_inhibit_manager = static_cast<struct zwp_idle_inhibit_manager_v1*>(
@@ -209,11 +207,15 @@ auto waybar::Client::setupCss(const std::string& css_file) -> void {
   }
 
   css_provider_ = Gtk::CssProvider::create();
-  if (!css_provider_->load_from_path(css_file)) {
-    css_provider_.reset();
-    throw std::runtime_error("Can't open style file");
+  if (has_8bit_hex(css_file)) {
+    std::string modified_css = transform_8bit_to_hex(css_file);
+    css_provider_->load_from_data(modified_css);
+  } else {
+    if (!css_provider_->load_from_path(css_file)) {
+      css_provider_.reset();
+      throw std::runtime_error("Can't open style file");
+    }
   }
-
   Gtk::StyleContext::add_provider_for_screen(screen, css_provider_,
                                              GTK_STYLE_PROVIDER_PRIORITY_USER);
 }
diff --git a/src/util/has_8bit_hex.cpp b/src/util/has_8bit_hex.cpp
new file mode 100644
index 00000000..db594980
--- /dev/null
+++ b/src/util/has_8bit_hex.cpp
@@ -0,0 +1,15 @@
+#include <filesystem>
+#include <fstream>
+#include <regex>
+
+namespace fs = std::filesystem;
+
+bool has_8bit_hex(std::string file_path) {
+  std::ifstream f(file_path, std::ios::in | std::ios::binary);
+  const auto size = fs::file_size(file_path);
+  std::string result(size, '\0');
+  f.read(result.data(), size);
+  std::regex pattern(
+      R"((?:\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})))");
+  return std::regex_search(result, pattern);
+}
diff --git a/src/util/transform_8bit_to_rgba.cpp b/src/util/transform_8bit_to_rgba.cpp
new file mode 100644
index 00000000..4e0cd3a8
--- /dev/null
+++ b/src/util/transform_8bit_to_rgba.cpp
@@ -0,0 +1,41 @@
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <regex>
+#include <sstream>
+namespace fs = std::filesystem;
+std::string transform_8bit_to_hex(std::string file_path) {
+  std::ifstream f(file_path, std::ios::in | std::ios::binary);
+  const auto size = fs::file_size(file_path);
+  std::string result(size, '\0');
+  f.read(result.data(), size);
+
+  std::regex pattern(
+      R"((?:\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})))");
+  std::string final_output;
+
+  auto it = std::sregex_iterator(result.begin(), result.end(), pattern);
+  auto eof = std::sregex_iterator();
+  std::smatch match = *it;
+
+  while (it != eof) {
+
+    final_output += match.prefix().str();
+
+    int r = stoi(match[1].str(), nullptr, 16);
+    int g = stoi(match[2].str(), nullptr, 16);
+    int b = stoi(match[3].str(), nullptr, 16);
+    double a = (stoi(match[4].str(), nullptr, 16) / 255.0);
+
+    std::stringstream ss;
+    ss << "rgba(" << r << "," << g << "," << b << "," << std::fixed
+       << std::setprecision(2) << a << ")";
+    final_output += ss.str();
+
+    ++it;
+  }
+
+  final_output += match.suffix().str();
+
+  return final_output;
+}

From 937ef176ffc5af51e243e744adc3d965ec8dd006 Mon Sep 17 00:00:00 2001
From: Keepo <bexel96@gmail.com>
Date: Sat, 28 Mar 2026 22:45:42 -0400
Subject: [PATCH 59/63] fix: memory issues & duplicate file loads.

---
 src/client.cpp                      |  4 ++--
 src/util/transform_8bit_to_rgba.cpp | 33 +++++++++++++++++++++++------
 2 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/src/client.cpp b/src/client.cpp
index 178552a4..d1489186 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -207,8 +207,8 @@ auto waybar::Client::setupCss(const std::string& css_file) -> void {
   }
 
   css_provider_ = Gtk::CssProvider::create();
-  if (has_8bit_hex(css_file)) {
-    std::string modified_css = transform_8bit_to_hex(css_file);
+  auto [modified_css, was_transformed] = transform_8bit_to_hex(css_file);
+  if (was_transformed) {
     css_provider_->load_from_data(modified_css);
   } else {
     if (!css_provider_->load_from_path(css_file)) {
diff --git a/src/util/transform_8bit_to_rgba.cpp b/src/util/transform_8bit_to_rgba.cpp
index 4e0cd3a8..ca95784d 100644
--- a/src/util/transform_8bit_to_rgba.cpp
+++ b/src/util/transform_8bit_to_rgba.cpp
@@ -4,21 +4,40 @@
 #include <regex>
 #include <sstream>
 namespace fs = std::filesystem;
-std::string transform_8bit_to_hex(std::string file_path) {
+
+struct TransformResult {
+  std::string css;
+  bool was_transformed;
+};
+
+TransformResult transform_8bit_to_hex(const std::string& file_path) {
   std::ifstream f(file_path, std::ios::in | std::ios::binary);
   const auto size = fs::file_size(file_path);
   std::string result(size, '\0');
+  if (!f.is_open() || !f.good()) {
+    throw std::runtime_error("Cannot open file: " + file_path);
+  }
+
+  if (size == 0) {
+    return {.css = result, .was_transformed = false};
+  }
+
   f.read(result.data(), size);
 
-  std::regex pattern(
-      R"((?:\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})))");
+  static std::regex pattern(
+      R"((\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})))");
   std::string final_output;
 
   auto it = std::sregex_iterator(result.begin(), result.end(), pattern);
   auto eof = std::sregex_iterator();
-  std::smatch match = *it;
 
+  if (it == eof) {
+    return {.css = result, .was_transformed = false};
+  }
+
+  std::smatch match;
   while (it != eof) {
+    match = *it;
 
     final_output += match.prefix().str();
 
@@ -28,8 +47,8 @@ std::string transform_8bit_to_hex(std::string file_path) {
     double a = (stoi(match[4].str(), nullptr, 16) / 255.0);
 
     std::stringstream ss;
-    ss << "rgba(" << r << "," << g << "," << b << "," << std::fixed
-       << std::setprecision(2) << a << ")";
+    ss << "rgba(" << r << "," << g << "," << b << "," << std::fixed << std::setprecision(2) << a
+       << ")";
     final_output += ss.str();
 
     ++it;
@@ -37,5 +56,5 @@ std::string transform_8bit_to_hex(std::string file_path) {
 
   final_output += match.suffix().str();
 
-  return final_output;
+  return {.css = final_output, .was_transformed = true};
 }

From 3533265675084b07ff5fb51f9b1ec8570080e954 Mon Sep 17 00:00:00 2001
From: Keepo <bexel96@gmail.com>
Date: Sat, 28 Mar 2026 23:02:16 -0400
Subject: [PATCH 60/63] fix: removed unnecessary function, update header file
 for signature change.

---
 include/util/hex_checker.hpp |  9 +--------
 src/util/has_8bit_hex.cpp    | 15 ---------------
 2 files changed, 1 insertion(+), 23 deletions(-)
 delete mode 100644 src/util/has_8bit_hex.cpp

diff --git a/include/util/hex_checker.hpp b/include/util/hex_checker.hpp
index 5e742436..e896031b 100644
--- a/include/util/hex_checker.hpp
+++ b/include/util/hex_checker.hpp
@@ -2,16 +2,9 @@
 
 #include <string>
 
-/**
- * Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
- * and returns true if found, or false if not found.
- */
-
-bool has_8bit_hex(std::string file_path);
-
 /**
  * Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
  * and transforms them into GTK-compatible rgba() syntax.
  */
 
-std::string transform_8bit_to_hex(std::string file_path);
+std::string transform_8bit_to_hex(const std::string& file_path);
diff --git a/src/util/has_8bit_hex.cpp b/src/util/has_8bit_hex.cpp
deleted file mode 100644
index db594980..00000000
--- a/src/util/has_8bit_hex.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <filesystem>
-#include <fstream>
-#include <regex>
-
-namespace fs = std::filesystem;
-
-bool has_8bit_hex(std::string file_path) {
-  std::ifstream f(file_path, std::ios::in | std::ios::binary);
-  const auto size = fs::file_size(file_path);
-  std::string result(size, '\0');
-  f.read(result.data(), size);
-  std::regex pattern(
-      R"((?:\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})))");
-  return std::regex_search(result, pattern);
-}

From 72d6a51fb7e2fe04aa36515b8db8107c03d3372e Mon Sep 17 00:00:00 2001
From: Keepo <bexel96@gmail.com>
Date: Sat, 28 Mar 2026 23:26:34 -0400
Subject: [PATCH 61/63] fix: fix compile/run bugs from trying to be safer. rip

---
 include/util/hex_checker.hpp        | 2 +-
 meson.build                         | 1 -
 src/util/transform_8bit_to_rgba.cpp | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/include/util/hex_checker.hpp b/include/util/hex_checker.hpp
index e896031b..9855c2de 100644
--- a/include/util/hex_checker.hpp
+++ b/include/util/hex_checker.hpp
@@ -7,4 +7,4 @@
  * and transforms them into GTK-compatible rgba() syntax.
  */
 
-std::string transform_8bit_to_hex(const std::string& file_path);
+std::pair<std::string, bool> transform_8bit_to_hex(const std::string& file_path);
diff --git a/meson.build b/meson.build
index b9df3f80..0c494eb2 100644
--- a/meson.build
+++ b/meson.build
@@ -186,7 +186,6 @@ src_files = files(
     'src/util/icon_loader.cpp',
     'src/util/regex_collection.cpp',
     'src/util/css_reload_helper.cpp',
-    'src/util/has_8bit_hex.cpp',
     'src/util/transform_8bit_to_rgba.cpp'
 )
 
diff --git a/src/util/transform_8bit_to_rgba.cpp b/src/util/transform_8bit_to_rgba.cpp
index ca95784d..dc87a88e 100644
--- a/src/util/transform_8bit_to_rgba.cpp
+++ b/src/util/transform_8bit_to_rgba.cpp
@@ -25,7 +25,7 @@ TransformResult transform_8bit_to_hex(const std::string& file_path) {
   f.read(result.data(), size);
 
   static std::regex pattern(
-      R"((\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})))");
+      R"(\#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2}))");
   std::string final_output;
 
   auto it = std::sregex_iterator(result.begin(), result.end(), pattern);

From a9aab4e3569a0c771a873e2a4b1c8695f70430e9 Mon Sep 17 00:00:00 2001
From: Keepo <bexel96@gmail.com>
Date: Sat, 28 Mar 2026 23:44:41 -0400
Subject: [PATCH 62/63] fix: type consistency

---
 include/util/hex_checker.hpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/include/util/hex_checker.hpp b/include/util/hex_checker.hpp
index 9855c2de..27a84d1f 100644
--- a/include/util/hex_checker.hpp
+++ b/include/util/hex_checker.hpp
@@ -2,9 +2,16 @@
 
 #include <string>
 
+/**
+ * Result of transforming 8-bit hex codes to rgba().
+ */
+struct TransformResult {
+  std::string css;
+  bool was_transformed;
+};
+
 /**
  * Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
  * and transforms them into GTK-compatible rgba() syntax.
  */
-
-std::pair<std::string, bool> transform_8bit_to_hex(const std::string& file_path);
+TransformResult transform_8bit_to_hex(const std::string& file_path);

From 3f69bacff018371507c9a8f8dbd78aa558a02cd1 Mon Sep 17 00:00:00 2001
From: Visal Vijay <visalvijay83@gmail.com>
Date: Sun, 29 Mar 2026 22:12:16 +0530
Subject: [PATCH 63/63] fix: prevent resource leak when rebinding dwl globals

---
 src/modules/dwl/tags.cpp | 34 +++++++++++++++++++++++++---------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/modules/dwl/tags.cpp b/src/modules/dwl/tags.cpp
index 399c7d4b..243aaa92 100644
--- a/src/modules/dwl/tags.cpp
+++ b/src/modules/dwl/tags.cpp
@@ -70,17 +70,33 @@ static const zdwl_ipc_output_v2_listener output_status_listener_impl{
 
 static void handle_global(void* data, struct wl_registry* registry, uint32_t name,
                           const char* interface, uint32_t version) {
-  if (std::strcmp(interface, zdwl_ipc_manager_v2_interface.name) == 0) {
-    static_cast<Tags*>(data)->status_manager_ = static_cast<struct zdwl_ipc_manager_v2*>(
-        (zdwl_ipc_manager_v2*)wl_registry_bind(registry, name, &zdwl_ipc_manager_v2_interface, 1));
-  }
-  if (std::strcmp(interface, wl_seat_interface.name) == 0) {
-    version = std::min<uint32_t>(version, 1);
-    static_cast<Tags*>(data)->seat_ =
-        static_cast<struct wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, version));
-  }
+  
+if (std::strcmp(interface, zdwl_ipc_manager_v2_interface.name) == 0) {
+  auto* self = static_cast<Tags*>(data);
+
+  if (self->status_manager_) {
+  zdwl_ipc_manager_v2_destroy(self->status_manager_);
+  self->status_manager_ = nullptr;
 }
 
+  self->status_manager_ = static_cast<struct zdwl_ipc_manager_v2*>(
+      wl_registry_bind(registry, name, &zdwl_ipc_manager_v2_interface, 1));
+}
+
+if (std::strcmp(interface, wl_seat_interface.name) == 0) {
+  auto* self = static_cast<Tags*>(data);
+
+  if (self->seat_) {
+    wl_seat_destroy(self->seat_);
+    self->seat_ = nullptr;
+  }
+
+  version = std::min<uint32_t>(version, 1);
+
+  self->seat_ = static_cast<struct wl_seat*>(
+      wl_registry_bind(registry, name, &wl_seat_interface, version));
+}
+}
 static void handle_global_remove(void* data, struct wl_registry* registry, uint32_t name) {
   /* Ignore event */
 }