redesign bt module/menu

Cargo.lock

@@ -111,17 +111,6 @@ dependencies = [
  "slab",
 ]
 
-[[package]]
-name = "async-fs"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
-dependencies = [
- "async-lock",
- "blocking",
- "futures-lite",
-]
-
 [[package]]
 name = "async-io"
 version = "2.6.0"
@@ -239,15 +228,6 @@ version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "block2"
 version = "0.6.2"
@@ -378,31 +358,12 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "cpufeatures"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
-[[package]]
-name = "crypto-common"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
 [[package]]
 name = "ctrlc"
 version = "3.5.2"
@@ -504,16 +465,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "crypto-common",
-]
-
 [[package]]
 name = "dispatch2"
 version = "0.3.1"
@@ -621,13 +572,14 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "fluxo-rs"
-version = "0.3.3"
+version = "0.5.0"
 dependencies = [
  "anyhow",
  "bluer",
  "clap",
  "ctrlc",
  "futures",
+ "libc",
  "libpulse-binding",
  "maestro",
  "nix 0.31.2",
@@ -768,27 +720,6 @@ dependencies = [
  "slab",
 ]
 
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
 [[package]]
 name = "getrandom"
 version = "0.4.2"
@@ -1071,7 +1002,6 @@ dependencies = [
  "cfg-if",
  "cfg_aliases",
  "libc",
- "memoffset",
 ]
 
 [[package]]
@@ -1304,15 +1234,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -1407,36 +1328,6 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom 0.2.17",
-]
-
 [[package]]
 name = "regex"
 version = "1.12.3"
@@ -1563,17 +1454,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "sha1"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -1615,12 +1495,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -1692,7 +1566,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.4.2",
+ "getrandom",
  "once_cell",
  "rustix",
  "windows-sys 0.61.2",
@@ -1791,7 +1665,7 @@ dependencies = [
  "toml_datetime",
  "toml_parser",
  "toml_writer",
- "winnow",
+ "winnow 1.0.1",
 ]
 
 [[package]]
@@ -1805,14 +1679,14 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.25.8+spec-1.1.0"
+version = "0.25.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16bff38f1d86c47f9ff0647e6838d7bb362522bdf44006c7068c2b1e606f1f3c"
+checksum = "a82418ca169e235e6c399a84e395ab6debeb3bc90edc959bf0f48647c6a32d1b"
 dependencies = [
  "indexmap",
  "toml_datetime",
  "toml_parser",
- "winnow",
+ "winnow 1.0.1",
 ]
 
 [[package]]
@@ -1821,7 +1695,7 @@ version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
- "winnow",
+ "winnow 1.0.1",
 ]
 
 [[package]]
@@ -1891,12 +1765,6 @@ dependencies = [
  "tracing-log",
 ]
 
-[[package]]
-name = "typenum"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
-
 [[package]]
 name = "uds_windows"
 version = "1.2.1"
@@ -1932,8 +1800,9 @@ version = "1.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9"
 dependencies = [
- "getrandom 0.4.2",
+ "getrandom",
  "js-sys",
+ "serde_core",
  "wasm-bindgen",
 ]
 
@@ -1943,12 +1812,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -2194,15 +2057,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
@@ -2368,6 +2222,15 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winnow"
 version = "1.0.1"
@@ -2465,25 +2328,14 @@ dependencies = [
  "wasmparser",
 ]
 
-[[package]]
-name = "xdg-home"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6"
-dependencies = [
- "libc",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "zbus"
-version = "4.4.0"
+version = "5.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725"
+checksum = "ca82f95dbd3943a40a53cfded6c2d0a2ca26192011846a1810c4256ef92c60bc"
 dependencies = [
  "async-broadcast",
  "async-executor",
- "async-fs",
  "async-io",
  "async-lock",
  "async-process",
@@ -2494,20 +2346,18 @@ dependencies = [
  "enumflags2",
  "event-listener",
  "futures-core",
- "futures-sink",
+ "futures-lite",
- "futures-util",
  "hex",
- "nix 0.29.0",
+ "libc",
  "ordered-stream",
- "rand",
+ "rustix",
  "serde",
  "serde_repr",
- "sha1",
- "static_assertions",
  "tracing",
  "uds_windows",
- "windows-sys 0.52.0",
+ "uuid",
- "xdg-home",
+ "windows-sys 0.61.2",
+ "winnow 0.7.15",
  "zbus_macros",
  "zbus_names",
  "zvariant",
@@ -2515,48 +2365,30 @@ dependencies = [
 
 [[package]]
 name = "zbus_macros"
-version = "4.4.0"
+version = "5.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e"
+checksum = "897e79616e84aac4b2c46e9132a4f63b93105d54fe8c0e8f6bffc21fa8d49222"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn",
+ "zbus_names",
+ "zvariant",
  "zvariant_utils",
 ]
 
 [[package]]
 name = "zbus_names"
-version = "3.0.0"
+version = "4.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c"
+checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f"
 dependencies = [
  "serde",
- "static_assertions",
+ "winnow 0.7.15",
  "zvariant",
 ]
 
-[[package]]
-name = "zerocopy"
-version = "0.8.48"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.48"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "zmij"
 version = "1.0.21"
@@ -2565,22 +2397,23 @@ checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 
 [[package]]
 name = "zvariant"
-version = "4.2.0"
+version = "5.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe"
+checksum = "5708299b21903bbe348e94729f22c49c55d04720a004aa350f1f9c122fd2540b"
 dependencies = [
  "endi",
  "enumflags2",
  "serde",
- "static_assertions",
+ "winnow 0.7.15",
  "zvariant_derive",
+ "zvariant_utils",
 ]
 
 [[package]]
 name = "zvariant_derive"
-version = "4.2.0"
+version = "5.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449"
+checksum = "5b59b012ebe9c46656f9cc08d8da8b4c726510aef12559da3e5f1bf72780752c"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2591,11 +2424,13 @@ dependencies = [
 
 [[package]]
 name = "zvariant_utils"
-version = "2.1.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340"
+checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9"
 dependencies = [
  "proc-macro2",
  "quote",
+ "serde",
  "syn",
+ "winnow 0.7.15",
 ]

Cargo.toml

@@ -1,12 +1,21 @@
 [package]
 name = "fluxo-rs"
-version = "0.4"
+version = "0.5.0"
 edition = "2024"
 
+[features]
+default = ["mod-audio", "mod-bt", "mod-network", "mod-hardware", "mod-dbus"]
+mod-audio = ["dep:libpulse-binding"]
+mod-bt = ["dep:bluer", "dep:maestro"]
+mod-network = ["dep:nix"]
+mod-hardware = []
+mod-dbus = ["dep:zbus", "dep:futures"]
+
 [dependencies]
 anyhow = "1.0.102"
 clap = { version = "4.6.0", features = ["derive"] }
 ctrlc = "3"
+libc = "0.2"
 regex = "1.12"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
@@ -15,16 +24,17 @@ thiserror = "2.0"
 toml = "1.1.2"
 tracing = "0.1.44"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
-maestro = { git = "https://github.com/qzed/pbpctrl", package = "maestro" }
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal", "process", "io-util", "net"] }
-bluer = { version = "0.17", features = ["bluetoothd", "rfcomm", "id"] }
-tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros", "signal", "process"] }
 tokio-util = { version = "0.7", features = ["codec", "time"] }
-futures = "0.3"
-libpulse-binding = "2.30"
-nix = { version = "0.31", features = ["net"] }
 notify = "8.2.0"
-zbus = "4"
+
+# Optional module dependencies
+maestro = { git = "https://github.com/qzed/pbpctrl", package = "maestro", optional = true }
+bluer = { version = "0.17", features = ["bluetoothd", "rfcomm", "id"], optional = true }
+futures = { version = "0.3", optional = true }
+libpulse-binding = { version = "2.30", optional = true }
+nix = { version = "0.31", features = ["net"], optional = true }
+zbus = { version = "5", optional = true }
 
 [dev-dependencies]
-
 tempfile = "3"

example.config.toml

@@ -29,40 +29,49 @@ backlight = 13
 dnd = 14
 
 [network]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {interface}, {ip}, {rx}, {tx}
 format = "{interface} ({ip}):  {rx:^4.1} MB/s   {tx:^4.1} MB/s"
 
 [cpu]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {usage}, {temp}, {model}
 format = "CPU: {usage:^4.1}% {temp:^4.1}C"
 
 [memory]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {used}, {total}
 format = "MEM: {used:^4.1}/{total:^4.1}GB"
 
 [gpu]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {usage}, {vram_used}, {vram_total}, {temp}
 format_amd = "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
 format_intel = "iGPU: {usage:>3.0}%"
 format_nvidia = "NV: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
 
 [sys]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {uptime}, {load1}, {load5}, {load15}, {procs}
 format = "UP: {uptime} LOAD: {load1:^3.1} "
 
 [disk]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {mount}, {used}, {total}
 format = "{mount} {used:^3.0}/{total:^3.0}G"
 
 [pool]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {used}, {total}
 format = "{used:>4.0}G / {total:>4.0}G"
 
 [power]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {percentage}, {icon}
 format = "{percentage:>3}%  {icon}"
 
 [audio]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {name}, {volume}, {icon}
 format_sink_unmuted = "{name} {volume:>3}% {icon}"
 format_sink_muted = "{name} {icon}"
@@ -70,6 +79,7 @@ format_source_unmuted = "{name} {volume:>3}% {icon}"
 format_source_muted = "{name} {icon}"
 
 [bt]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {alias}, {mac}, {left}, {right}, {anc}
 format_plugin = "{alias} [{left}|{right}] {anc} 󰂰"
 format_connected = "󰂰 {alias}"
@@ -77,21 +87,30 @@ format_disconnected = "󰂯 Disconnected"
 format_disabled = "󰂲 Off"
 
 [game]
+# enabled = false  # set to false to disable this module at runtime
 format_active = "<span size='large'>󰊖</span>"
 format_inactive = "<span size='large'></span>"
 
 [mpris]
+# enabled = false  # set to false to disable this module at runtime
+# max_length = 30          # truncate text beyond this character length (adds '...')
+# scroll = true            # enable marquee scroll animation (requires max_length)
+# scroll_speed = 500       # ms between scroll steps (only while playing)
+# scroll_separator = " /// "  # separator shown between loops when scrolling
 # tokens: {artist}, {title}, {album}, {status_icon}
 format = "{status_icon} {artist} - {title}"
 
 [backlight]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {percentage}, {icon}
 format = "{percentage:>3}% {icon}"
 
 [keyboard]
+# enabled = false  # set to false to disable this module at runtime
 # tokens: {layout}
 format = "{layout}"
 
 [dnd]
+# enabled = false  # set to false to disable this module at runtime
 format_dnd = "<span size='large'>󰂛</span>"
 format_normal = "<span size='large'>󰂚</span>"

src/config.rs

@@ -1,8 +1,6 @@
-use regex::Regex;
 use serde::Deserialize;
 use std::fs;
 use std::path::PathBuf;
-use std::sync::LazyLock;
 use tracing::{debug, info, warn};
 
 #[derive(Deserialize, Default, Clone)]
@@ -11,34 +9,49 @@ pub struct Config {
     pub general: GeneralConfig,
     #[serde(default)]
     pub signals: SignalsConfig,
+    #[cfg(feature = "mod-network")]
     #[serde(default)]
     pub network: NetworkConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub cpu: CpuConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub memory: MemoryConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub gpu: GpuConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub sys: SysConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub disk: DiskConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub pool: PoolConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub power: PowerConfig,
+    #[cfg(feature = "mod-audio")]
     #[serde(default)]
     pub audio: AudioConfig,
+    #[cfg(feature = "mod-bt")]
     #[serde(default)]
     pub bt: BtConfig,
+    #[cfg(feature = "mod-hardware")]
     #[serde(default)]
     pub game: GameConfig,
+    #[cfg(feature = "mod-dbus")]
     #[serde(default)]
     pub mpris: MprisConfig,
+    #[cfg(feature = "mod-dbus")]
     #[serde(default)]
     pub backlight: BacklightConfig,
+    #[cfg(feature = "mod-dbus")]
     #[serde(default)]
     pub keyboard: KeyboardConfig,
+    #[cfg(feature = "mod-dbus")]
     #[serde(default)]
     pub dnd: DndConfig,
 }
@@ -78,12 +91,15 @@ pub struct SignalsConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct NetworkConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for NetworkConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{interface} ({ip}):  {rx:>5.2} MB/s   {tx:>5.2} MB/s".to_string(),
         }
     }
@@ -91,12 +107,15 @@ impl Default for NetworkConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct CpuConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for CpuConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "CPU: {usage:>4.1}% {temp:>4.1}C".to_string(),
         }
     }
@@ -104,12 +123,15 @@ impl Default for CpuConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct MemoryConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for MemoryConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{used:>5.2}/{total:>5.2}GB".to_string(),
         }
     }
@@ -117,6 +139,8 @@ impl Default for MemoryConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct GpuConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format_amd: String,
     pub format_intel: String,
     pub format_nvidia: String,
@@ -125,6 +149,7 @@ pub struct GpuConfig {
 impl Default for GpuConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format_amd: "AMD: {usage:>3.0}% {vram_used:>4.1}/{vram_total:>4.1}GB {temp:>4.1}C"
                 .to_string(),
             format_intel: "iGPU: {usage:>3.0}%".to_string(),
@@ -136,12 +161,15 @@ impl Default for GpuConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct SysConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for SysConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "UP: {uptime} | LOAD: {load1:>4.2} {load5:>4.2} {load15:>4.2}".to_string(),
         }
     }
@@ -149,12 +177,15 @@ impl Default for SysConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct DiskConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for DiskConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{mount} {used:>5.1}/{total:>5.1}G".to_string(),
         }
     }
@@ -162,12 +193,15 @@ impl Default for DiskConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct PoolConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for PoolConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{used:>4.0}G / {total:>4.0}G".to_string(),
         }
     }
@@ -175,12 +209,15 @@ impl Default for PoolConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct PowerConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for PowerConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{percentage:>3}%  {icon}".to_string(),
         }
     }
@@ -188,6 +225,8 @@ impl Default for PowerConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct AudioConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format_sink_unmuted: String,
     pub format_sink_muted: String,
     pub format_source_unmuted: String,
@@ -197,6 +236,7 @@ pub struct AudioConfig {
 impl Default for AudioConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format_sink_unmuted: "{name} {volume:>3}% {icon}".to_string(),
             format_sink_muted: "{name} {icon}".to_string(),
             format_source_unmuted: "{name} {volume:>3}% {icon}".to_string(),
@@ -207,6 +247,8 @@ impl Default for AudioConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct BtConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format_connected: String,
     pub format_plugin: String,
     pub format_disconnected: String,
@@ -216,6 +258,7 @@ pub struct BtConfig {
 impl Default for BtConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format_connected: "{alias} 󰂰".to_string(),
             format_plugin: "{alias} [{left}|{right}] {anc} 󰂰".to_string(),
             format_disconnected: "󰂯".to_string(),
@@ -226,6 +269,8 @@ impl Default for BtConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct GameConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format_active: String,
     pub format_inactive: String,
 }
@@ -233,6 +278,7 @@ pub struct GameConfig {
 impl Default for GameConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format_active: "<span size='large'>󰊖</span>".to_string(),
             format_inactive: "<span size='large'></span>".to_string(),
         }
@@ -241,25 +287,51 @@ impl Default for GameConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct MprisConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
+    #[serde(default)]
+    pub max_length: Option<usize>,
+    #[serde(default)]
+    pub scroll: bool,
+    #[serde(default = "default_scroll_speed")]
+    pub scroll_speed: u64,
+    #[serde(default = "default_scroll_separator")]
+    pub scroll_separator: String,
+}
+
+fn default_scroll_speed() -> u64 {
+    500
+}
+
+fn default_scroll_separator() -> String {
+    " /// ".to_string()
 }
 
 impl Default for MprisConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{status_icon} {artist} - {title}".to_string(),
+            max_length: None,
+            scroll: false,
+            scroll_speed: 500,
+            scroll_separator: " /// ".to_string(),
         }
     }
 }
 
 #[derive(Deserialize, Clone)]
 pub struct BacklightConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for BacklightConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{percentage:>3}% {icon}".to_string(),
         }
     }
@@ -267,12 +339,15 @@ impl Default for BacklightConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct KeyboardConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format: String,
 }
 
 impl Default for KeyboardConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format: "{layout}".to_string(),
         }
     }
@@ -280,24 +355,28 @@ impl Default for KeyboardConfig {
 
 #[derive(Deserialize, Clone)]
 pub struct DndConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
     pub format_dnd: String,
     pub format_normal: String,
 }
 
+fn default_true() -> bool {
+    true
+}
+
 impl Default for DndConfig {
     fn default() -> Self {
         Self {
+            enabled: true,
             format_dnd: "<span size='large'>󰂛</span>".to_string(),
             format_normal: "<span size='large'>󰂚</span>".to_string(),
         }
     }
 }
 
-static TOKEN_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap());
-
 fn extract_tokens(format_str: &str) -> Vec<String> {
-    TOKEN_RE
+    crate::utils::TOKEN_RE
         .captures_iter(format_str)
         .map(|cap| cap[1].to_string())
         .collect()
@@ -315,79 +394,132 @@ fn validate_format(label: &str, format_str: &str, known_tokens: &[&str]) {
 }
 
 impl Config {
+    /// Check if a module is enabled in the configuration.
+    /// Returns false if the module is explicitly disabled; true if enabled or unknown.
+    pub fn is_module_enabled(&self, module_name: &str) -> bool {
+        match module_name {
+            #[cfg(feature = "mod-network")]
+            "net" | "network" => self.network.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "cpu" => self.cpu.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "mem" | "memory" => self.memory.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "gpu" => self.gpu.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "sys" => self.sys.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "disk" => self.disk.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "pool" | "btrfs" => self.pool.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "power" => self.power.enabled,
+            #[cfg(feature = "mod-hardware")]
+            "game" => self.game.enabled,
+            #[cfg(feature = "mod-audio")]
+            "vol" | "audio" | "mic" => self.audio.enabled,
+            #[cfg(feature = "mod-bt")]
+            "bt" | "bluetooth" => self.bt.enabled,
+            #[cfg(feature = "mod-dbus")]
+            "mpris" => self.mpris.enabled,
+            #[cfg(feature = "mod-dbus")]
+            "backlight" => self.backlight.enabled,
+            #[cfg(feature = "mod-dbus")]
+            "kbd" | "keyboard" => self.keyboard.enabled,
+            #[cfg(feature = "mod-dbus")]
+            "dnd" => self.dnd.enabled,
+            _ => true,
+        }
+    }
+
     pub fn validate(&self) {
+        #[cfg(feature = "mod-network")]
         validate_format(
             "network",
             &self.network.format,
             &["interface", "ip", "rx", "tx"],
         );
-        validate_format("cpu", &self.cpu.format, &["usage", "temp"]);
+        #[cfg(feature = "mod-hardware")]
-        validate_format("memory", &self.memory.format, &["used", "total"]);
+        {
-        validate_format(
+            validate_format("cpu", &self.cpu.format, &["usage", "temp"]);
-            "gpu.amd",
+            validate_format("memory", &self.memory.format, &["used", "total"]);
-            &self.gpu.format_amd,
+            validate_format(
-            &["usage", "vram_used", "vram_total", "temp"],
+                "gpu.amd",
-        );
+                &self.gpu.format_amd,
-        validate_format("gpu.intel", &self.gpu.format_intel, &["usage", "freq"]);
+                &["usage", "vram_used", "vram_total", "temp"],
-        validate_format(
+            );
-            "gpu.nvidia",
+            validate_format("gpu.intel", &self.gpu.format_intel, &["usage", "freq"]);
-            &self.gpu.format_nvidia,
+            validate_format(
-            &["usage", "vram_used", "vram_total", "temp"],
+                "gpu.nvidia",
-        );
+                &self.gpu.format_nvidia,
-        validate_format(
+                &["usage", "vram_used", "vram_total", "temp"],
-            "sys",
+            );
-            &self.sys.format,
+            validate_format(
-            &["uptime", "load1", "load5", "load15", "procs"],
+                "sys",
-        );
+                &self.sys.format,
-        validate_format("disk", &self.disk.format, &["mount", "used", "total"]);
+                &["uptime", "load1", "load5", "load15", "procs"],
-        validate_format("pool", &self.pool.format, &["used", "total"]);
+            );
-        validate_format("power", &self.power.format, &["percentage", "icon"]);
+            validate_format("disk", &self.disk.format, &["mount", "used", "total"]);
-        validate_format(
+            validate_format("pool", &self.pool.format, &["used", "total"]);
-            "audio.sink_unmuted",
+            validate_format("power", &self.power.format, &["percentage", "icon"]);
-            &self.audio.format_sink_unmuted,
+        }
-            &["name", "icon", "volume"],
+        #[cfg(feature = "mod-audio")]
-        );
+        {
-        validate_format(
+            validate_format(
-            "audio.sink_muted",
+                "audio.sink_unmuted",
-            &self.audio.format_sink_muted,
+                &self.audio.format_sink_unmuted,
-            &["name", "icon"],
+                &["name", "icon", "volume"],
-        );
+            );
-        validate_format(
+            validate_format(
-            "audio.source_unmuted",
+                "audio.sink_muted",
-            &self.audio.format_source_unmuted,
+                &self.audio.format_sink_muted,
-            &["name", "icon", "volume"],
+                &["name", "icon"],
-        );
+            );
-        validate_format(
+            validate_format(
-            "audio.source_muted",
+                "audio.source_unmuted",
-            &self.audio.format_source_muted,
+                &self.audio.format_source_unmuted,
-            &["name", "icon"],
+                &["name", "icon", "volume"],
-        );
+            );
-        validate_format("bt.connected", &self.bt.format_connected, &["alias"]);
+            validate_format(
-        validate_format(
+                "audio.source_muted",
-            "bt.plugin",
+                &self.audio.format_source_muted,
-            &self.bt.format_plugin,
+                &["name", "icon"],
-            &["alias", "left", "right", "anc", "mac"],
+            );
-        );
+        }
-        validate_format(
+        #[cfg(feature = "mod-bt")]
-            "mpris",
+        {
-            &self.mpris.format,
+            validate_format("bt.connected", &self.bt.format_connected, &["alias"]);
-            &["artist", "title", "album", "status_icon"],
+            validate_format(
-        );
+                "bt.plugin",
-        validate_format("backlight", &self.backlight.format, &["percentage", "icon"]);
+                &self.bt.format_plugin,
-        validate_format("keyboard", &self.keyboard.format, &["layout"]);
+                &["alias", "left", "right", "anc", "mac"],
+            );
+        }
+        #[cfg(feature = "mod-dbus")]
+        {
+            validate_format(
+                "mpris",
+                &self.mpris.format,
+                &["artist", "title", "album", "status_icon"],
+            );
+            validate_format("backlight", &self.backlight.format, &["percentage", "icon"]);
+            validate_format("keyboard", &self.keyboard.format, &["layout"]);
+        }
     }
 }
 
+pub fn default_config_path() -> PathBuf {
+    let config_dir = std::env::var("XDG_CONFIG_HOME")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            let home = std::env::var("HOME").unwrap_or_else(|_| String::from("/"));
+            PathBuf::from(home).join(".config")
+        });
+    config_dir.join("fluxo/config.toml")
+}
+
 pub fn load_config(custom_path: Option<PathBuf>) -> Config {
-    let config_path = custom_path.unwrap_or_else(|| {
+    let config_path = custom_path.unwrap_or_else(default_config_path);
-        let config_dir = std::env::var("XDG_CONFIG_HOME")
-            .map(PathBuf::from)
-            .unwrap_or_else(|_| {
-                let home = std::env::var("HOME").unwrap_or_else(|_| String::from("/"));
-                PathBuf::from(home).join(".config")
-            });
-        config_dir.join("fluxo/config.toml")
-    });
 
     if let Ok(content) = fs::read_to_string(&config_path) {
         match toml::from_str::<Config>(&content) {

src/daemon.rs

@@ -1,14 +1,20 @@
 use crate::config::Config;
-use crate::error::FluxoError;
 use crate::ipc::socket_path;
-use crate::modules::WaybarModule;
+#[cfg(feature = "mod-audio")]
 use crate::modules::audio::AudioDaemon;
+#[cfg(feature = "mod-dbus")]
 use crate::modules::backlight::BacklightDaemon;
+#[cfg(feature = "mod-bt")]
 use crate::modules::bt::BtDaemon;
+#[cfg(feature = "mod-dbus")]
 use crate::modules::dnd::DndDaemon;
+#[cfg(feature = "mod-hardware")]
 use crate::modules::hardware::HardwareDaemon;
+#[cfg(feature = "mod-dbus")]
 use crate::modules::keyboard::KeyboardDaemon;
+#[cfg(feature = "mod-dbus")]
 use crate::modules::mpris::MprisDaemon;
+#[cfg(feature = "mod-network")]
 use crate::modules::network::NetworkDaemon;
 use crate::signaler::WaybarSignaler;
 use crate::state::AppReceivers;
@@ -21,9 +27,9 @@ use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::net::UnixListener;
 use tokio::sync::{RwLock, mpsc, watch};
-use tokio::time::{Duration, Instant, sleep};
+use tokio::time::{Duration, sleep};
 use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info};
 
 struct SocketGuard {
     path: String,
@@ -37,15 +43,7 @@ impl Drop for SocketGuard {
 }
 
 fn get_config_path(custom_path: Option<PathBuf>) -> PathBuf {
-    custom_path.unwrap_or_else(|| {
+    custom_path.unwrap_or_else(crate::config::default_config_path)
-        let config_dir = std::env::var("XDG_CONFIG_HOME")
-            .map(PathBuf::from)
-            .unwrap_or_else(|_| {
-                let home = std::env::var("HOME").unwrap_or_else(|_| String::from("/"));
-                PathBuf::from(home).join(".config")
-            });
-        config_dir.join("fluxo/config.toml")
-    })
 }
 
 pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
@@ -56,37 +54,77 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
         fs::remove_file(&sock_path)?;
     }
 
+    #[cfg(feature = "mod-network")]
     let (net_tx, net_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
     let (cpu_tx, cpu_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
     let (mem_tx, mem_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
     let (sys_tx, sys_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
     let (gpu_tx, gpu_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-hardware")]
     let (disks_tx, disks_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-bt")]
     let (bt_tx, bt_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-audio")]
     let (audio_tx, audio_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
     let (mpris_tx, mpris_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
     let (backlight_tx, backlight_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
     let (keyboard_tx, keyboard_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
     let (dnd_tx, dnd_rx) = watch::channel(Default::default());
+    #[cfg(feature = "mod-dbus")]
+    let mpris_scroll = Arc::new(RwLock::new(crate::state::MprisScrollState::default()));
+    #[cfg(feature = "mod-dbus")]
+    let (mpris_scroll_tick_tx, mpris_scroll_tick_rx) = watch::channel(0u64);
     let health = Arc::new(RwLock::new(HashMap::new()));
+    #[cfg(feature = "mod-bt")]
     let (bt_force_tx, mut bt_force_rx) = mpsc::channel(1);
+    #[cfg(feature = "mod-bt")]
+    let bt_cycle = Arc::new(RwLock::new(0usize));
+    #[cfg(feature = "mod-audio")]
     let (audio_cmd_tx, audio_cmd_rx) = mpsc::channel(8);
 
     let receivers = AppReceivers {
+        #[cfg(feature = "mod-network")]
         network: net_rx,
+        #[cfg(feature = "mod-hardware")]
         cpu: cpu_rx,
+        #[cfg(feature = "mod-hardware")]
         memory: mem_rx,
+        #[cfg(feature = "mod-hardware")]
         sys: sys_rx,
+        #[cfg(feature = "mod-hardware")]
         gpu: gpu_rx,
+        #[cfg(feature = "mod-hardware")]
         disks: disks_rx,
+        #[cfg(feature = "mod-bt")]
         bluetooth: bt_rx,
+        #[cfg(feature = "mod-bt")]
+        bt_cycle,
+        #[cfg(feature = "mod-audio")]
         audio: audio_rx,
+        #[cfg(feature = "mod-dbus")]
         mpris: mpris_rx,
+        #[cfg(feature = "mod-dbus")]
         backlight: backlight_rx,
+        #[cfg(feature = "mod-dbus")]
         keyboard: keyboard_rx,
+        #[cfg(feature = "mod-dbus")]
         dnd: dnd_rx,
+        #[cfg(feature = "mod-dbus")]
+        mpris_scroll: Arc::clone(&mpris_scroll),
+        #[cfg(feature = "mod-dbus")]
+        mpris_scroll_tick: mpris_scroll_tick_rx,
         health: Arc::clone(&health),
+        #[cfg(feature = "mod-bt")]
         bt_force_poll: bt_force_tx,
+        #[cfg(feature = "mod-audio")]
         audio_cmd_tx,
     };
 
@@ -156,101 +194,152 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     });
 
     // 1. Network Task
-    let token = cancel_token.clone();
+    #[cfg(feature = "mod-network")]
-    let net_health = Arc::clone(&health);
+    if config.read().await.network.enabled {
-    tokio::spawn(async move {
+        let token = cancel_token.clone();
-        info!("Starting Network polling task");
+        let net_health = Arc::clone(&health);
-        let mut daemon = NetworkDaemon::new();
+        tokio::spawn(async move {
-        loop {
+            info!("Starting Network polling task");
-            if !is_in_backoff("net", &net_health).await {
+            let mut daemon = NetworkDaemon::new();
-                let res = daemon.poll(&net_tx).await;
+            loop {
-                handle_poll_result("net", res, &net_health).await;
+                if !crate::health::is_poll_in_backoff("net", &net_health).await {
+                    let res = daemon.poll(&net_tx).await;
+                    crate::health::handle_poll_result("net", res, &net_health).await;
+                }
+                tokio::select! {
+                    _ = token.cancelled() => break,
+                    _ = sleep(Duration::from_secs(1)) => {}
+                }
             }
-            tokio::select! {
+            info!("Network task shut down.");
-                _ = token.cancelled() => break,
+        });
-                _ = sleep(Duration::from_secs(1)) => {}
+    }
-            }
-        }
-        info!("Network task shut down.");
-    });
 
     // 2. Fast Hardware Task (CPU, Mem, Load)
-    let token = cancel_token.clone();
+    #[cfg(feature = "mod-hardware")]
-    let hw_health = Arc::clone(&health);
+    {
-    tokio::spawn(async move {
+        let cfg = config.read().await;
-        info!("Starting Fast Hardware polling task");
+        let fast_enabled = cfg.cpu.enabled || cfg.memory.enabled || cfg.sys.enabled;
-        let mut daemon = HardwareDaemon::new();
+        drop(cfg);
-        loop {
+        if fast_enabled {
-            if !is_in_backoff("cpu", &hw_health).await {
+            let token = cancel_token.clone();
-                daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx).await;
+            let hw_health = Arc::clone(&health);
-            }
+            tokio::spawn(async move {
-            tokio::select! {
+                info!("Starting Fast Hardware polling task");
-                _ = token.cancelled() => break,
+                let mut daemon = HardwareDaemon::new();
-                _ = sleep(Duration::from_secs(1)) => {}
+                loop {
-            }
+                    if !crate::health::is_poll_in_backoff("cpu", &hw_health).await {
+                        daemon.poll_fast(&cpu_tx, &mem_tx, &sys_tx).await;
+                    }
+                    tokio::select! {
+                        _ = token.cancelled() => break,
+                        _ = sleep(Duration::from_secs(1)) => {}
+                    }
+                }
+                info!("Fast Hardware task shut down.");
+            });
         }
-        info!("Fast Hardware task shut down.");
+    }
-    });
 
     // 3. Slow Hardware Task (GPU, Disks)
-    let token = cancel_token.clone();
+    #[cfg(feature = "mod-hardware")]
-    let slow_health = Arc::clone(&health);
+    {
-    tokio::spawn(async move {
+        let cfg = config.read().await;
-        info!("Starting Slow Hardware polling task");
+        let slow_enabled = cfg.gpu.enabled || cfg.disk.enabled;
-        let mut daemon = HardwareDaemon::new();
+        drop(cfg);
-        loop {
+        if slow_enabled {
-            if !is_in_backoff("gpu", &slow_health).await {
+            let token = cancel_token.clone();
-                daemon.poll_slow(&gpu_tx, &disks_tx).await;
+            let slow_health = Arc::clone(&health);
-            }
+            tokio::spawn(async move {
-            tokio::select! {
+                info!("Starting Slow Hardware polling task");
-                _ = token.cancelled() => break,
+                let mut daemon = HardwareDaemon::new();
-                _ = sleep(Duration::from_secs(5)) => {}
+                loop {
-            }
+                    if !crate::health::is_poll_in_backoff("gpu", &slow_health).await {
+                        daemon.poll_slow(&gpu_tx, &disks_tx).await;
+                    }
+                    tokio::select! {
+                        _ = token.cancelled() => break,
+                        _ = sleep(Duration::from_secs(5)) => {}
+                    }
+                }
+                info!("Slow Hardware task shut down.");
+            });
         }
-        info!("Slow Hardware task shut down.");
+    }
-    });
 
     // 4. Bluetooth Task
-    let token = cancel_token.clone();
+    #[cfg(feature = "mod-bt")]
-    let bt_health = Arc::clone(&health);
+    if config.read().await.bt.enabled {
-    let poll_config = Arc::clone(&config);
+        let token = cancel_token.clone();
-    let poll_receivers = receivers.clone();
+        let bt_health = Arc::clone(&health);
-    tokio::spawn(async move {
+        let poll_config = Arc::clone(&config);
-        info!("Starting Bluetooth polling task");
+        let poll_receivers = receivers.clone();
-        let mut daemon = BtDaemon::new();
+        tokio::spawn(async move {
-        loop {
+            info!("Starting Bluetooth polling task");
-            if !is_in_backoff("bt", &bt_health).await {
+            let mut daemon = BtDaemon::new();
-                let config = poll_config.read().await;
+            loop {
-                daemon.poll(&bt_tx, &poll_receivers, &config).await;
+                if !crate::health::is_poll_in_backoff("bt", &bt_health).await {
+                    let config = poll_config.read().await;
+                    daemon.poll(&bt_tx, &poll_receivers, &config).await;
+                }
+                tokio::select! {
+                    _ = token.cancelled() => break,
+                    _ = bt_force_rx.recv() => {},
+                    _ = sleep(Duration::from_secs(2)) => {}
+                }
             }
-            tokio::select! {
+            info!("Bluetooth task shut down.");
-                _ = token.cancelled() => break,
+        });
-                _ = bt_force_rx.recv() => {},
+    }
-                _ = sleep(Duration::from_secs(2)) => {}
-            }
-        }
-        info!("Bluetooth task shut down.");
-    });
 
     // 5. Audio Thread (Event driven)
-    let audio_daemon = AudioDaemon::new();
+    #[cfg(feature = "mod-audio")]
-    audio_daemon.start(&audio_tx, audio_cmd_rx);
+    if config.read().await.audio.enabled {
+        let audio_daemon = AudioDaemon::new();
+        audio_daemon.start(&audio_tx, audio_cmd_rx);
+    }
 
     // 5.1 Backlight Thread (Event driven)
-    let backlight_daemon = BacklightDaemon::new();
+    #[cfg(feature = "mod-dbus")]
-    backlight_daemon.start(backlight_tx);
+    if config.read().await.backlight.enabled {
+        let backlight_daemon = BacklightDaemon::new();
+        backlight_daemon.start(backlight_tx);
+    }
 
     // 5.2 Keyboard Thread (Event driven)
-    let keyboard_daemon = KeyboardDaemon::new();
+    #[cfg(feature = "mod-dbus")]
-    keyboard_daemon.start(keyboard_tx);
+    if config.read().await.keyboard.enabled {
+        let keyboard_daemon = KeyboardDaemon::new();
+        keyboard_daemon.start(keyboard_tx);
+    }
 
     // 5.3 DND Thread (Event driven)
-    let dnd_daemon = DndDaemon::new();
+    #[cfg(feature = "mod-dbus")]
-    dnd_daemon.start(dnd_tx);
+    if config.read().await.dnd.enabled {
+        let dnd_daemon = DndDaemon::new();
+        dnd_daemon.start(dnd_tx);
+    }
 
     // 5.4 MPRIS Thread
-    let mpris_daemon = MprisDaemon::new();
+    #[cfg(feature = "mod-dbus")]
-    mpris_daemon.start(mpris_tx);
+    if config.read().await.mpris.enabled {
+        let mpris_daemon = MprisDaemon::new();
+        mpris_daemon.start(mpris_tx);
+
+        // Scroll ticker for MPRIS marquee animation
+        let scroll_config = Arc::clone(&config);
+        let scroll_rx = receivers.mpris.clone();
+        let scroll_state = Arc::clone(&mpris_scroll);
+        tokio::spawn(async move {
+            crate::modules::mpris::mpris_scroll_ticker(
+                scroll_config,
+                scroll_rx,
+                scroll_state,
+                mpris_scroll_tick_tx,
+            )
+            .await;
+        });
+    }
 
     // 6. Waybar Signaler Task
     let signaler = WaybarSignaler::new();
@@ -324,59 +413,6 @@ pub async fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
     Ok(())
 }
 
-async fn handle_poll_result(
-    module_name: &str,
-    result: crate::error::Result<()>,
-    health_lock: &Arc<RwLock<HashMap<String, crate::state::ModuleHealth>>>,
-) {
-    let mut lock = health_lock.write().await;
-    let health = lock.entry(module_name.to_string()).or_default();
-
-    match result {
-        Ok(_) => {
-            if health.consecutive_failures > 0 {
-                info!(
-                    module = module_name,
-                    "Module recovered after {} failures", health.consecutive_failures
-                );
-            }
-            health.consecutive_failures = 0;
-            health.backoff_until = None;
-        }
-        Err(e) => {
-            health.consecutive_failures += 1;
-            health.last_failure = Some(Instant::now());
-
-            if !e.is_transient() {
-                // Fatal errors trigger immediate long backoff
-                health.backoff_until = Some(Instant::now() + Duration::from_secs(60));
-                error!(module = module_name, error = %e, "Fatal module error, entering long cooldown");
-            } else if health.consecutive_failures >= 3 {
-                // Exponential backoff for transient errors: 30s, 60s, 120s...
-                let backoff_secs = 30 * (2u64.pow(health.consecutive_failures.saturating_sub(3)));
-                let backoff_secs = backoff_secs.min(3600); // Cap at 1 hour
-                health.backoff_until = Some(Instant::now() + Duration::from_secs(backoff_secs));
-                warn!(module = module_name, error = %e, backoff = backoff_secs, "Repeated transient failures, entering backoff");
-            } else {
-                debug!(module = module_name, error = %e, "Transient module failure (attempt {})", health.consecutive_failures);
-            }
-        }
-    }
-}
-
-async fn is_in_backoff(
-    module_name: &str,
-    health_lock: &Arc<RwLock<HashMap<String, crate::state::ModuleHealth>>>,
-) -> bool {
-    let lock = health_lock.read().await;
-    if let Some(health) = lock.get(module_name)
-        && let Some(until) = health.backoff_until
-    {
-        return Instant::now() < until;
-    }
-    false
-}
-
 pub async fn reload_config(config_lock: &Arc<RwLock<Config>>, path: Option<PathBuf>) {
     info!("Reloading configuration...");
     let new_config = crate::config::load_config(path);
@@ -390,74 +426,11 @@ pub async fn evaluate_module_for_signaler(
     state: &AppReceivers,
     config: &Config,
 ) -> Option<String> {
-    let result = match module_name {
+    let args = crate::registry::signaler_default_args(module_name);
-        "net" | "network" => {
+    crate::registry::dispatch(module_name, config, state, args)
-            crate::modules::network::NetworkModule
+        .await
-                .run(config, state, &[])
+        .ok()
-                .await
+        .and_then(|out| serde_json::to_string(&out).ok())
-        }
-        "cpu" => crate::modules::cpu::CpuModule.run(config, state, &[]).await,
-        "mem" | "memory" => {
-            crate::modules::memory::MemoryModule
-                .run(config, state, &[])
-                .await
-        }
-        "disk" => {
-            crate::modules::disk::DiskModule
-                .run(config, state, &["/"])
-                .await
-        }
-        "pool" | "btrfs" => {
-            crate::modules::btrfs::BtrfsModule
-                .run(config, state, &["btrfs"])
-                .await
-        }
-        "vol" | "audio" => {
-            crate::modules::audio::AudioModule
-                .run(config, state, &["sink", "show"])
-                .await
-        }
-        "mic" => {
-            crate::modules::audio::AudioModule
-                .run(config, state, &["source", "show"])
-                .await
-        }
-        "gpu" => crate::modules::gpu::GpuModule.run(config, state, &[]).await,
-        "sys" => crate::modules::sys::SysModule.run(config, state, &[]).await,
-        "bt" | "bluetooth" => {
-            crate::modules::bt::BtModule
-                .run(config, state, &["show"])
-                .await
-        }
-        "power" => {
-            crate::modules::power::PowerModule
-                .run(config, state, &[])
-                .await
-        }
-        "game" => {
-            crate::modules::game::GameModule
-                .run(config, state, &[])
-                .await
-        }
-        "backlight" => {
-            crate::modules::backlight::BacklightModule
-                .run(config, state, &[])
-                .await
-        }
-        "kbd" | "keyboard" => {
-            crate::modules::keyboard::KeyboardModule
-                .run(config, state, &[])
-                .await
-        }
-        "dnd" => crate::modules::dnd::DndModule.run(config, state, &[]).await,
-        "mpris" => {
-            crate::modules::mpris::MprisModule
-                .run(config, state, &[])
-                .await
-        }
-        _ => return None,
-    };
-    result.ok().and_then(|out| serde_json::to_string(&out).ok())
 }
 
 async fn handle_request(
@@ -466,160 +439,22 @@ async fn handle_request(
     state: &AppReceivers,
     config_lock: &Arc<RwLock<Config>>,
 ) -> String {
-    // 1. Check Circuit Breaker status
+    let (is_in_backoff, cached_output) = crate::health::check_backoff(module_name, state).await;
-    let (is_in_backoff, cached_output) = {
-        let lock = state.health.read().await;
-        if let Some(health) = lock.get(module_name) {
-            let in_backoff = if let Some(until) = health.backoff_until {
-                Instant::now() < until
-            } else {
-                false
-            };
-            (in_backoff, health.last_successful_output.clone())
-        } else {
-            (false, None)
-        }
-    };
 
     if is_in_backoff {
-        if let Some(mut cached) = cached_output {
+        return crate::health::backoff_response(module_name, cached_output);
-            // Add a "warning" class to indicate stale data
-            let class = cached.class.unwrap_or_default();
-            cached.class = Some(format!("{} warning", class).trim().to_string());
-            return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
-        }
-        return format!(
-            "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
-            module_name
-        );
     }
 
     let config = config_lock.read().await;
+    let result = crate::registry::dispatch(module_name, &config, state, args).await;
 
-    let result = match module_name {
+    crate::health::update_health(module_name, &result, state).await;
-        "net" | "network" => {
-            crate::modules::network::NetworkModule
-                .run(&config, state, args)
-                .await
-        }
-        "cpu" => {
-            crate::modules::cpu::CpuModule
-                .run(&config, state, args)
-                .await
-        }
-        "mem" | "memory" => {
-            crate::modules::memory::MemoryModule
-                .run(&config, state, args)
-                .await
-        }
-        "disk" => {
-            crate::modules::disk::DiskModule
-                .run(&config, state, args)
-                .await
-        }
-        "pool" | "btrfs" => {
-            crate::modules::btrfs::BtrfsModule
-                .run(&config, state, args)
-                .await
-        }
-        "vol" | "audio" => {
-            crate::modules::audio::AudioModule
-                .run(&config, state, args)
-                .await
-        }
-        "mic" => {
-            crate::modules::audio::AudioModule
-                .run(&config, state, args)
-                .await
-        }
-        "gpu" => {
-            crate::modules::gpu::GpuModule
-                .run(&config, state, args)
-                .await
-        }
-        "sys" => {
-            crate::modules::sys::SysModule
-                .run(&config, state, args)
-                .await
-        }
-        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(&config, state, args).await,
-        "power" => {
-            crate::modules::power::PowerModule
-                .run(&config, state, args)
-                .await
-        }
-        "game" => {
-            crate::modules::game::GameModule
-                .run(&config, state, args)
-                .await
-        }
-        "backlight" => {
-            crate::modules::backlight::BacklightModule
-                .run(&config, state, args)
-                .await
-        }
-        "kbd" | "keyboard" => {
-            crate::modules::keyboard::KeyboardModule
-                .run(&config, state, args)
-                .await
-        }
-        "dnd" => {
-            crate::modules::dnd::DndModule
-                .run(&config, state, args)
-                .await
-        }
-        "mpris" => {
-            crate::modules::mpris::MprisModule
-                .run(&config, state, args)
-                .await
-        }
-        _ => {
-            warn!("Received request for unknown module: '{}'", module_name);
-            Err(FluxoError::Ipc(format!("Unknown module: {}", module_name)))
-        }
-    };
-
-    // 2. Update Health and Cache based on result
-    {
-        let mut lock = state.health.write().await;
-        let health = lock.entry(module_name.to_string()).or_default();
-        match &result {
-            Ok(output) => {
-                health.consecutive_failures = 0;
-                health.backoff_until = None;
-                health.last_successful_output = Some(output.clone());
-            }
-            Err(e) => {
-                health.consecutive_failures += 1;
-                health.last_failure = Some(Instant::now());
-                if health.consecutive_failures >= 3 {
-                    // Backoff for 30 seconds after 3 failures
-                    health.backoff_until = Some(Instant::now() + Duration::from_secs(30));
-                    warn!(module = module_name, error = %e, "Module entered backoff state due to repeated failures");
-                }
-            }
-        }
-    }
 
     match result {
         Ok(output) => serde_json::to_string(&output).unwrap_or_else(|_| "{}".to_string()),
-        Err(e) => {
+        Err(crate::error::FluxoError::Disabled(_)) => {
-            // If we have a cached output, return it as fallback even on immediate error
+            "{\"text\":\"\",\"tooltip\":\"Module disabled\",\"class\":\"disabled\"}".to_string()
-            if let Some(mut cached) = cached_output {
-                let class = cached.class.unwrap_or_default();
-                cached.class = Some(format!("{} warning", class).trim().to_string());
-                return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
-            }
-
-            let error_msg = e.to_string();
-            error!(module = module_name, error = %error_msg, "Module execution failed");
-            let err_out = crate::output::WaybarOutput {
-                text: "\u{200B}Error\u{200B}".to_string(),
-                tooltip: Some(error_msg),
-                class: Some("error".to_string()),
-                percentage: None,
-            };
-            serde_json::to_string(&err_out).unwrap_or_else(|_| "{}".to_string())
         }
+        Err(e) => crate::health::error_response(module_name, &e, cached_output),
     }
 }

src/error.rs

@@ -33,6 +33,9 @@ pub enum FluxoError {
     #[error("Serialization error: {0}")]
     Serialization(#[from] serde_json::Error),
 
+    #[error("Module disabled: {0}")]
+    Disabled(String),
+
     #[error("Other error: {0}")]
     Other(#[from] anyhow::Error),
 }

src/health.rs

@@ -0,0 +1,136 @@
+use crate::output::WaybarOutput;
+use crate::state::{AppReceivers, ModuleHealth};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tokio::time::{Duration, Instant};
+use tracing::{debug, error, info, warn};
+
+/// Check if a module is in backoff (used by request handler).
+pub async fn check_backoff(
+    module_name: &str,
+    state: &AppReceivers,
+) -> (bool, Option<WaybarOutput>) {
+    let lock = state.health.read().await;
+    if let Some(health) = lock.get(module_name) {
+        let in_backoff = health
+            .backoff_until
+            .is_some_and(|until| Instant::now() < until);
+        (in_backoff, health.last_successful_output.clone())
+    } else {
+        (false, None)
+    }
+}
+
+/// Update health after a request dispatch (used by request handler).
+pub async fn update_health(
+    module_name: &str,
+    result: &Result<WaybarOutput, crate::error::FluxoError>,
+    state: &AppReceivers,
+) {
+    let mut lock = state.health.write().await;
+    let health = lock.entry(module_name.to_string()).or_default();
+    match result {
+        Ok(output) => {
+            health.consecutive_failures = 0;
+            health.backoff_until = None;
+            health.last_successful_output = Some(output.clone());
+        }
+        Err(crate::error::FluxoError::Disabled(_)) => {}
+        Err(e) => {
+            health.consecutive_failures += 1;
+            health.last_failure = Some(Instant::now());
+            if health.consecutive_failures >= 3 {
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(30));
+                warn!(module = module_name, error = %e, "Module entered backoff state due to repeated failures");
+            }
+        }
+    }
+}
+
+/// Check if a polling daemon module is in backoff.
+pub async fn is_poll_in_backoff(
+    module_name: &str,
+    health_lock: &Arc<RwLock<HashMap<String, ModuleHealth>>>,
+) -> bool {
+    let lock = health_lock.read().await;
+    if let Some(health) = lock.get(module_name)
+        && let Some(until) = health.backoff_until
+    {
+        return Instant::now() < until;
+    }
+    false
+}
+
+/// Update health after a polling daemon result.
+pub async fn handle_poll_result(
+    module_name: &str,
+    result: crate::error::Result<()>,
+    health_lock: &Arc<RwLock<HashMap<String, ModuleHealth>>>,
+) {
+    let mut lock = health_lock.write().await;
+    let health = lock.entry(module_name.to_string()).or_default();
+
+    match result {
+        Ok(_) => {
+            if health.consecutive_failures > 0 {
+                info!(
+                    module = module_name,
+                    "Module recovered after {} failures", health.consecutive_failures
+                );
+            }
+            health.consecutive_failures = 0;
+            health.backoff_until = None;
+        }
+        Err(e) => {
+            health.consecutive_failures += 1;
+            health.last_failure = Some(Instant::now());
+
+            if !e.is_transient() {
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(60));
+                error!(module = module_name, error = %e, "Fatal module error, entering long cooldown");
+            } else if health.consecutive_failures >= 3 {
+                let backoff_secs = 30 * (2u64.pow(health.consecutive_failures.saturating_sub(3)));
+                let backoff_secs = backoff_secs.min(3600);
+                health.backoff_until = Some(Instant::now() + Duration::from_secs(backoff_secs));
+                warn!(module = module_name, error = %e, backoff = backoff_secs, "Repeated transient failures, entering backoff");
+            } else {
+                debug!(module = module_name, error = %e, "Transient module failure (attempt {})", health.consecutive_failures);
+            }
+        }
+    }
+}
+
+pub fn backoff_response(module_name: &str, cached: Option<WaybarOutput>) -> String {
+    if let Some(mut cached) = cached {
+        let class = cached.class.unwrap_or_default();
+        cached.class = Some(format!("{} warning", class).trim().to_string());
+        return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
+    }
+    format!(
+        "{{\"text\":\"\u{200B}Cooling down ({})\u{200B}\",\"class\":\"error\"}}",
+        module_name
+    )
+}
+
+pub fn error_response(
+    module_name: &str,
+    e: &crate::error::FluxoError,
+    cached: Option<WaybarOutput>,
+) -> String {
+    if let Some(mut cached) = cached {
+        let class = cached.class.unwrap_or_default();
+        cached.class = Some(format!("{} warning", class).trim().to_string());
+        return serde_json::to_string(&cached).unwrap_or_else(|_| "{}".to_string());
+    }
+
+    let error_msg = e.to_string();
+    error!(module = module_name, error = %error_msg, "Module execution failed");
+    let err_out = WaybarOutput {
+        text: "\u{200B}Error\u{200B}".to_string(),
+        tooltip: Some(error_msg),
+        class: Some("error".to_string()),
+        percentage: None,
+    };
+    serde_json::to_string(&err_out).unwrap_or_else(|_| "{}".to_string())
+}

src/main.rs

@@ -1,9 +1,11 @@
 mod config;
 mod daemon;
 mod error;
+mod health;
 mod ipc;
 mod modules;
 mod output;
+mod registry;
 mod signaler;
 mod state;
 mod utils;
@@ -76,47 +78,84 @@ fn main() {
 
     if let Some(module) = &cli.module {
         // Special case for client-side Bluetooth menu which requires UI
+        #[cfg(feature = "mod-bt")]
         if module == "bt" && cli.args.first().map(|s| s.as_str()) == Some("menu") {
             let config = config::load_config(None);
             let mut items = Vec::new();
 
-            if let Ok(json_str) = ipc::request_data("bt", &["get_modes"])
+            // Parse menu_data to get connected and paired devices
-                && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
+            let mut connected: Vec<(String, String)> = Vec::new(); // (alias, mac)
-                && let Some(modes_str) = val.get("text").and_then(|t| t.as_str())
+            let mut paired: Vec<(String, String)> = Vec::new();
-                && !modes_str.is_empty()
-            {
-                for mode in modes_str.lines() {
-                    items.push(format!("Mode: {}", mode));
-                }
-            }
-
-            if !items.is_empty() {
-                items.push("Disconnect".to_string());
-            }
-
-            items.push("--- Connect Device ---".to_string());
 
             if let Ok(json_str) = ipc::request_data("bt", &["menu_data"])
                 && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
-                && let Some(devices_str) = val.get("text").and_then(|t| t.as_str())
+                && let Some(text) = val.get("text").and_then(|t| t.as_str())
             {
-                for line in devices_str.lines() {
+                for line in text.lines() {
-                    if !line.is_empty() {
+                    if let Some(rest) = line.strip_prefix("CONNECTED:")
-                        items.push(line.to_string());
+                        && let Some((alias, mac)) = rest.split_once('|')
+                    {
+                        connected.push((alias.to_string(), mac.to_string()));
+                    } else if let Some(rest) = line.strip_prefix("PAIRED:")
+                        && let Some((alias, mac)) = rest.split_once('|')
+                    {
+                        paired.push((alias.to_string(), mac.to_string()));
                     }
                 }
             }
 
+            // Per-device sections for connected devices
+            for (alias, mac) in &connected {
+                // Get modes for this specific device
+                if let Ok(json_str) = ipc::request_data("bt", &["get_modes", mac])
+                    && let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str)
+                    && let Some(modes_str) = val.get("text").and_then(|t| t.as_str())
+                    && !modes_str.is_empty()
+                {
+                    for mode in modes_str.lines() {
+                        items.push(format!("{}: Mode: {} [{}]", alias, mode, mac));
+                    }
+                }
+                items.push(format!("Disconnect {} [{}]", alias, mac));
+            }
+
+            // Separator and paired devices for connecting
+            if !paired.is_empty() {
+                items.push("--- Connect Device ---".to_string());
+                for (alias, mac) in &paired {
+                    items.push(format!("{} ({})", alias, mac));
+                }
+            }
+
             if !items.is_empty() {
                 if let Ok(selected) =
                     utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
                 {
-                    if let Some(mode) = selected.strip_prefix("Mode: ") {
+                    if selected.contains(": Mode: ") {
-                        handle_ipc_response(ipc::request_data("bt", &["set_mode", mode]));
+                        // "<alias>: Mode: <mode> [<MAC>]"
-                    } else if selected == "Disconnect" {
+                        if let Some(bracket_start) = selected.rfind('[')
-                        handle_ipc_response(ipc::request_data("bt", &["disconnect"]));
+                            && let Some(bracket_end) = selected.rfind(']')
+                        {
+                            let mac = &selected[bracket_start + 1..bracket_end];
+                            if let Some(mode_start) = selected.find(": Mode: ") {
+                                let mode =
+                                    &selected[mode_start + ": Mode: ".len()..bracket_start - 1];
+                                handle_ipc_response(ipc::request_data(
+                                    "bt",
+                                    &["set_mode", mode, mac],
+                                ));
+                            }
+                        }
+                    } else if selected.starts_with("Disconnect ") {
+                        // "Disconnect <alias> [<MAC>]"
+                        if let Some(bracket_start) = selected.rfind('[')
+                            && let Some(bracket_end) = selected.rfind(']')
+                        {
+                            let mac = &selected[bracket_start + 1..bracket_end];
+                            handle_ipc_response(ipc::request_data("bt", &["disconnect", mac]));
+                        }
                     } else if selected == "--- Connect Device ---" {
-                        // Do nothing
+                        // separator, do nothing
                     } else if let Some(mac_start) = selected.rfind('(')
                         && let Some(mac_end) = selected.rfind(')')
                     {

src/modules/audio.rs

@@ -9,6 +9,7 @@ use libpulse_binding::context::subscribe::{Facility, InterestMaskSet};
 use libpulse_binding::context::{Context, FlagSet as ContextFlag};
 use libpulse_binding::mainloop::threaded::Mainloop as ThreadedMainloop;
 use libpulse_binding::volume::Volume;
+use std::sync::Arc;
 use tokio::sync::{mpsc, watch};
 use tracing::error;
 
@@ -230,15 +231,16 @@ fn fetch_audio_data_sync(
     });
 
     let tx_sink = state_tx.clone();
+    let pending_sinks: Arc<std::sync::Mutex<Vec<String>>> =
+        Arc::new(std::sync::Mutex::new(Vec::new()));
+    let pending_sinks_cb = Arc::clone(&pending_sinks);
     context.introspect().get_sink_info_list(move |res| {
         let mut current = tx_sink.borrow().clone();
         match res {
             ListResult::Item(item) => {
                 if let Some(name) = item.name.as_ref() {
                     let name_str = name.to_string();
-                    if !current.available_sinks.contains(&name_str) {
+                    pending_sinks_cb.lock().unwrap().push(name_str);
-                        current.available_sinks.push(name_str);
-                    }
                 }
 
                 let is_default = item
@@ -261,8 +263,7 @@ fn fetch_audio_data_sync(
                 let _ = tx_sink.send(current);
             }
             ListResult::End => {
-                // Clear the list on End so it rebuilds fresh next time
+                current.available_sinks = pending_sinks_cb.lock().unwrap().drain(..).collect();
-                current.available_sinks.clear();
                 let _ = tx_sink.send(current);
             }
             ListResult::Error => {}
@@ -270,17 +271,17 @@ fn fetch_audio_data_sync(
     });
 
     let tx_source = state_tx.clone();
+    let pending_sources: Arc<std::sync::Mutex<Vec<String>>> =
+        Arc::new(std::sync::Mutex::new(Vec::new()));
+    let pending_sources_cb = Arc::clone(&pending_sources);
     context.introspect().get_source_info_list(move |res| {
         let mut current = tx_source.borrow().clone();
         match res {
             ListResult::Item(item) => {
                 if let Some(name) = item.name.as_ref() {
                     let name_str = name.to_string();
-                    // PulseAudio includes monitor sources, ignore them if we want to
+                    if !name_str.contains(".monitor") {
-                    if !name_str.contains(".monitor")
+                        pending_sources_cb.lock().unwrap().push(name_str);
-                        && !current.available_sources.contains(&name_str)
-                    {
-                        current.available_sources.push(name_str);
                     }
                 }
 
@@ -304,8 +305,7 @@ fn fetch_audio_data_sync(
                 let _ = tx_source.send(current);
             }
             ListResult::End => {
-                // Clear the list on End so it rebuilds fresh next time
+                current.available_sources = pending_sources_cb.lock().unwrap().drain(..).collect();
-                current.available_sources.clear();
                 let _ = tx_source.send(current);
             }
             ListResult::Error => {}
@@ -331,19 +331,19 @@ impl WaybarModule for AudioModule {
         match *action {
             "up" => {
                 self.change_volume(state, target_type, step, true).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "down" => {
                 self.change_volume(state, target_type, step, false).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "mute" => {
                 self.toggle_mute(state, target_type).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "cycle" => {
                 self.cycle_device(state, target_type).await?;
-                Ok(WaybarOutput::default())
+                self.get_status(config, state, target_type).await
             }
             "show" => self.get_status(config, state, target_type).await,
             other => Err(FluxoError::Module {

src/modules/bt/mod.rs

@@ -5,7 +5,7 @@ use crate::config::Config;
 use crate::error::Result as FluxoResult;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::{AppReceivers, BtState};
+use crate::state::{AppReceivers, BtDeviceInfo, BtState};
 use crate::utils::{TokenValue, format_template};
 use anyhow::Result;
 use std::sync::LazyLock;
@@ -47,60 +47,64 @@ impl BtDaemon {
         let adapter = session.default_adapter().await?;
         let adapter_powered = adapter.is_powered().await.unwrap_or(false);
 
-        let mut bt_state = BtState {
+        let mut connected_devices = Vec::new();
-            adapter_powered,
-            ..Default::default()
-        };
 
         if adapter_powered {
-            let devices = adapter.device_addresses().await?;
+            let mut addresses = adapter.device_addresses().await?;
-            for addr in devices {
+            addresses.sort();
-                let device = adapter.device(addr)?;
+            let audio_sink_uuid = bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
-                if device.is_connected().await.unwrap_or(false) {
-                    let uuids = device.uuids().await?.unwrap_or_default();
-                    let audio_sink_uuid =
-                        bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
-                    if uuids.contains(&audio_sink_uuid) {
-                        bt_state.connected = true;
-                        bt_state.device_address = addr.to_string();
-                        bt_state.device_alias =
-                            device.alias().await.unwrap_or_else(|_| addr.to_string());
-                        bt_state.battery_percentage =
-                            device.battery_percentage().await.unwrap_or(None);
 
-                        for p in PLUGINS.iter() {
+            for addr in addresses {
-                            if p.can_handle(&bt_state.device_alias, &bt_state.device_address) {
+                let device = adapter.device(addr)?;
-                                match p.get_data(config, state, &bt_state.device_address).await {
+                if !device.is_connected().await.unwrap_or(false) {
-                                    Ok(data) => {
+                    continue;
-                                        bt_state.plugin_data = data
+                }
-                                            .into_iter()
+                let uuids = device.uuids().await?.unwrap_or_default();
-                                            .map(|(k, v)| {
+                if !uuids.contains(&audio_sink_uuid) {
-                                                let val_str = match v {
+                    continue;
-                                                    TokenValue::String(s) => s,
+                }
-                                                    TokenValue::Int(i) => i.to_string(),
+
-                                                    TokenValue::Float(f) => format!("{:.1}", f),
+                let mut dev_info = BtDeviceInfo {
-                                                };
+                    device_address: addr.to_string(),
-                                                (k, val_str)
+                    device_alias: device.alias().await.unwrap_or_else(|_| addr.to_string()),
-                                            })
+                    battery_percentage: device.battery_percentage().await.unwrap_or(None),
-                                            .collect();
+                    plugin_data: vec![],
-                                    }
+                };
-                                    Err(e) => {
+
-                                        warn!("Plugin {} failed for {}: {}", p.name(), addr, e);
+                for p in PLUGINS.iter() {
-                                        bt_state
+                    if p.can_handle(&dev_info.device_alias, &dev_info.device_address) {
-                                            .plugin_data
+                        match p.get_data(config, state, &dev_info.device_address).await {
-                                            .push(("plugin_error".to_string(), e.to_string()));
+                            Ok(data) => {
-                                    }
+                                dev_info.plugin_data = data
-                                }
+                                    .into_iter()
-                                break;
+                                    .map(|(k, v)| {
+                                        let val_str = match v {
+                                            TokenValue::String(s) => s,
+                                            TokenValue::Int(i) => i.to_string(),
+                                            TokenValue::Float(f) => format!("{:.1}", f),
+                                        };
+                                        (k, val_str)
+                                    })
+                                    .collect();
+                            }
+                            Err(e) => {
+                                warn!("Plugin {} failed for {}: {}", p.name(), addr, e);
+                                dev_info
+                                    .plugin_data
+                                    .push(("plugin_error".to_string(), e.to_string()));
                             }
                         }
                         break;
                     }
                 }
+                connected_devices.push(dev_info);
             }
         }
 
-        let _ = tx.send(bt_state);
+        let _ = tx.send(BtState {
+            adapter_powered,
+            devices: connected_devices,
+        });
 
         Ok(())
     }
@@ -111,8 +115,6 @@ static PLUGINS: LazyLock<Vec<Box<dyn BtPlugin>>> =
 
 fn trigger_robust_poll(state: AppReceivers) {
     tokio::spawn(async move {
-        // Poll immediately and then a few times over the next few seconds
-        // to catch slow state changes in bluez or plugins.
         for delay in [200, 500, 1000, 2000, 3000] {
             tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
             let _ = state.bt_force_poll.try_send(());
@@ -120,6 +122,26 @@ fn trigger_robust_poll(state: AppReceivers) {
     });
 }
 
+/// Resolve a target MAC: use explicit arg if given, otherwise fall back to the active device.
+async fn resolve_target_mac(
+    bt_state: &BtState,
+    state: &AppReceivers,
+    explicit_mac: Option<&str>,
+) -> Option<String> {
+    if let Some(mac) = explicit_mac {
+        return Some(mac.to_string());
+    }
+    let idx = *state.bt_cycle.read().await;
+    bt_state
+        .active_device(idx)
+        .map(|d| d.device_address.clone())
+}
+
+/// Find a device in the current state by MAC.
+fn find_device<'a>(bt_state: &'a BtState, mac: &str) -> Option<&'a BtDeviceInfo> {
+    bt_state.devices.iter().find(|d| d.device_address == mac)
+}
+
 pub struct BtModule;
 
 impl WaybarModule for BtModule {
@@ -129,12 +151,10 @@ impl WaybarModule for BtModule {
         state: &AppReceivers,
         args: &[&str],
     ) -> FluxoResult<WaybarOutput> {
-        let action = args.first().cloned().unwrap_or("show").to_string();
+        let action = args.first().cloned().unwrap_or("show");
-        let args = args.iter().map(|s| s.to_string()).collect::<Vec<_>>();
-
         let bt_state = state.bluetooth.borrow().clone();
 
-        match action.as_str() {
+        match action {
             "connect" => {
                 if let Some(mac) = args.get(1) {
                     if let Ok(session) = bluer::Session::new().await
@@ -148,77 +168,125 @@ impl WaybarModule for BtModule {
                 }
                 return Ok(WaybarOutput::default());
             }
-            "disconnect" if bt_state.connected => {
+            "disconnect" => {
-                if let Ok(session) = bluer::Session::new().await
+                let target_mac = resolve_target_mac(&bt_state, state, args.get(1).copied()).await;
-                    && let Ok(adapter) = session.default_adapter().await
+                if let Some(mac) = target_mac {
-                    && let Ok(addr) = bt_state.device_address.parse::<bluer::Address>()
+                    if let Ok(session) = bluer::Session::new().await
-                    && let Ok(device) = adapter.device(addr)
+                        && let Ok(adapter) = session.default_adapter().await
-                {
+                        && let Ok(addr) = mac.parse::<bluer::Address>()
-                    let _ = device.disconnect().await;
+                        && let Ok(device) = adapter.device(addr)
-                }
+                    {
-                trigger_robust_poll(state.clone());
+                        let _ = device.disconnect().await;
-                return Ok(WaybarOutput::default());
-            }
-            "menu_data" => {
-                let mut devs = Vec::new();
-                if let Ok(session) = bluer::Session::new().await
-                    && let Ok(adapter) = session.default_adapter().await
-                    && let Ok(addresses) = adapter.device_addresses().await
-                {
-                    for addr in addresses {
-                        if let Ok(device) = adapter.device(addr)
-                            && device.is_paired().await.unwrap_or(false)
-                        {
-                            let alias = device.alias().await.unwrap_or_else(|_| addr.to_string());
-                            devs.push(format!("{} ({})", alias, addr));
-                        }
                     }
-                }
-                return Ok(WaybarOutput {
-                    text: devs.join("\n"),
-                    ..Default::default()
-                });
-            }
-            "cycle_mode" if bt_state.connected => {
-                let plugin = PLUGINS
-                    .iter()
-                    .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
-                if let Some(p) = plugin {
-                    p.cycle_mode(&bt_state.device_address, state).await?;
                     trigger_robust_poll(state.clone());
                 }
                 return Ok(WaybarOutput::default());
             }
-            "get_modes" if bt_state.connected => {
+            "cycle" => {
-                let plugin = PLUGINS
+                let count = bt_state.devices.len();
-                    .iter()
+                if count > 1 {
-                    .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
+                    let mut idx = state.bt_cycle.write().await;
-                let modes = if let Some(p) = plugin {
+                    *idx = (*idx + 1) % count;
-                    p.get_modes(&bt_state.device_address, state).await?
+                }
-                } else {
+                let _ = state.bt_force_poll.try_send(());
-                    vec![]
+                return Ok(WaybarOutput::default());
-                };
+            }
+            "menu_data" => {
+                let mut lines = Vec::new();
+
+                // Connected devices
+                for dev in &bt_state.devices {
+                    lines.push(format!(
+                        "CONNECTED:{}|{}",
+                        dev.device_alias, dev.device_address
+                    ));
+                }
+
+                // Paired-but-not-connected devices
+                if let Ok(session) = bluer::Session::new().await
+                    && let Ok(adapter) = session.default_adapter().await
+                    && let Ok(addresses) = adapter.device_addresses().await
+                {
+                    let connected_macs: std::collections::HashSet<&str> = bt_state
+                        .devices
+                        .iter()
+                        .map(|d| d.device_address.as_str())
+                        .collect();
+
+                    for addr in addresses {
+                        let addr_str = addr.to_string();
+                        if connected_macs.contains(addr_str.as_str()) {
+                            continue;
+                        }
+                        if let Ok(device) = adapter.device(addr)
+                            && device.is_paired().await.unwrap_or(false)
+                        {
+                            let alias = device.alias().await.unwrap_or_else(|_| addr.to_string());
+                            lines.push(format!("PAIRED:{}|{}", alias, addr_str));
+                        }
+                    }
+                }
+
                 return Ok(WaybarOutput {
-                    text: modes.join("\n"),
+                    text: lines.join("\n"),
                     ..Default::default()
                 });
             }
-            "set_mode" if bt_state.connected => {
+            "get_modes" => {
-                if let Some(mode) = args.get(1) {
+                let target_mac = resolve_target_mac(&bt_state, state, args.get(1).copied()).await;
+                if let Some(mac) = target_mac
+                    && let Some(dev) = find_device(&bt_state, &mac)
+                {
                     let plugin = PLUGINS
                         .iter()
-                        .find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
+                        .find(|p| p.can_handle(&dev.device_alias, &dev.device_address));
                     if let Some(p) = plugin {
-                        p.set_mode(mode, &bt_state.device_address, state).await?;
+                        let modes = p.get_modes(&mac, state).await?;
+                        return Ok(WaybarOutput {
+                            text: modes.join("\n"),
+                            ..Default::default()
+                        });
+                    }
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "set_mode" => {
+                if let Some(mode) = args.get(1) {
+                    let target_mac =
+                        resolve_target_mac(&bt_state, state, args.get(2).copied()).await;
+                    if let Some(mac) = target_mac
+                        && let Some(dev) = find_device(&bt_state, &mac)
+                    {
+                        let plugin = PLUGINS
+                            .iter()
+                            .find(|p| p.can_handle(&dev.device_alias, &dev.device_address));
+                        if let Some(p) = plugin {
+                            p.set_mode(mode, &mac, state).await?;
+                            trigger_robust_poll(state.clone());
+                        }
+                    }
+                }
+                return Ok(WaybarOutput::default());
+            }
+            "cycle_mode" => {
+                let target_mac = resolve_target_mac(&bt_state, state, args.get(1).copied()).await;
+                if let Some(mac) = target_mac
+                    && let Some(dev) = find_device(&bt_state, &mac)
+                {
+                    let plugin = PLUGINS
+                        .iter()
+                        .find(|p| p.can_handle(&dev.device_alias, &dev.device_address));
+                    if let Some(p) = plugin {
+                        p.cycle_mode(&mac, state).await?;
                         trigger_robust_poll(state.clone());
                     }
                 }
                 return Ok(WaybarOutput::default());
             }
-            "show" => {}
             _ => {}
         }
 
+        // "show" and fallthrough
         if !bt_state.adapter_powered {
             return Ok(WaybarOutput {
                 text: config.bt.format_disabled.clone(),
@@ -228,22 +296,23 @@ impl WaybarModule for BtModule {
             });
         }
 
-        if bt_state.connected {
+        let cycle_idx = *state.bt_cycle.read().await;
+        if let Some(dev) = bt_state.active_device(cycle_idx) {
             let mut tokens: Vec<(String, TokenValue)> = vec![
                 (
                     "alias".to_string(),
-                    TokenValue::String(bt_state.device_alias.clone()),
+                    TokenValue::String(dev.device_alias.clone()),
                 ),
                 (
                     "mac".to_string(),
-                    TokenValue::String(bt_state.device_address.clone()),
+                    TokenValue::String(dev.device_address.clone()),
                 ),
             ];
 
             let mut class = vec!["connected".to_string()];
             let mut has_plugin = false;
 
-            for (k, v) in &bt_state.plugin_data {
+            for (k, v) in &dev.plugin_data {
                 if k == "plugin_class" {
                     class.push(v.clone());
                     has_plugin = true;
@@ -263,10 +332,9 @@ impl WaybarModule for BtModule {
             let text = format_template(format, &tokens);
             let tooltip = format!(
                 "{} | MAC: {}\nBattery: {}",
-                bt_state.device_alias,
+                dev.device_alias,
-                bt_state.device_address,
+                dev.device_address,
-                bt_state
+                dev.battery_percentage
-                    .battery_percentage
                     .map(|b| format!("{}%", b))
                     .unwrap_or_else(|| "N/A".to_string())
             );
@@ -275,7 +343,7 @@ impl WaybarModule for BtModule {
                 text,
                 tooltip: Some(tooltip),
                 class: Some(class.join(" ")),
-                percentage: bt_state.battery_percentage,
+                percentage: dev.battery_percentage,
             })
         } else {
             Ok(WaybarOutput {

src/modules/btrfs.rs

@@ -3,7 +3,7 @@ use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 pub struct BtrfsModule;
 
@@ -44,13 +44,7 @@ impl WaybarModule for BtrfsModule {
         let size_gb = total_size / 1024.0 / 1024.0 / 1024.0;
         let percentage = (total_used / total_size) * 100.0;
 
-        let class = if percentage > 95.0 {
+        let class = classify_usage(percentage, 80.0, 95.0);
-            "max"
-        } else if percentage > 80.0 {
-            "high"
-        } else {
-            "normal"
-        };
 
         let text = format_template(
             &config.pool.format,

src/modules/cpu.rs

@@ -3,7 +3,7 @@ use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 pub struct CpuModule;
 
@@ -27,13 +27,7 @@ impl WaybarModule for CpuModule {
             ],
         );
 
-        let class = if usage > 95.0 {
+        let class = classify_usage(usage, 75.0, 95.0);
-            "max"
-        } else if usage > 75.0 {
-            "high"
-        } else {
-            "normal"
-        };
 
         Ok(WaybarOutput {
             text,

src/modules/disk.rs

@@ -3,7 +3,7 @@ use crate::error::{FluxoError, Result};
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 pub struct DiskModule;
 
@@ -41,13 +41,7 @@ impl WaybarModule for DiskModule {
                     0.0
                 };
 
-                let class = if percentage > 95.0 {
+                let class = classify_usage(percentage, 80.0, 95.0);
-                    "max"
-                } else if percentage > 80.0 {
-                    "high"
-                } else {
-                    "normal"
-                };
 
                 let text = format_template(
                     &config.disk.format,
@@ -121,7 +115,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_disk_not_found() {
-        let state = mock_state(AppState::default());
+        let state = state_with_disk("/", 100, 50);
         let config = Config::default();
         let result = DiskModule
             .run(&config, &state.receivers, &["/nonexistent"])

src/modules/dnd.rs

@@ -5,8 +5,9 @@ use crate::output::WaybarOutput;
 use crate::state::{AppReceivers, DndState};
 use futures::StreamExt;
 use tokio::sync::watch;
+use tokio::time::Duration;
 use tracing::{debug, error, info};
-use zbus::{Connection, fdo::PropertiesProxy, proxy};
+use zbus::{Connection, fdo::PropertiesProxy, names::InterfaceName, proxy};
 
 pub struct DndModule;
 
@@ -15,8 +16,41 @@ impl WaybarModule for DndModule {
         &self,
         config: &Config,
         state: &AppReceivers,
-        _args: &[&str],
+        args: &[&str],
     ) -> Result<WaybarOutput> {
+        let action = args.first().unwrap_or(&"show");
+
+        if *action == "toggle" {
+            let connection =
+                Connection::session()
+                    .await
+                    .map_err(|e| crate::error::FluxoError::Module {
+                        module: "dnd",
+                        message: format!("DBus connection failed: {}", e),
+                    })?;
+
+            // Try toggling SwayNC
+            if let Ok(proxy) = SwayncControlProxy::new(&connection).await
+                && let Ok(is_dnd) = proxy.dnd().await
+            {
+                let _ = proxy.set_dnd(!is_dnd).await;
+                return Ok(WaybarOutput::default());
+            }
+
+            // Try toggling Dunst
+            if let Ok(proxy) = DunstControlProxy::new(&connection).await
+                && let Ok(is_paused) = proxy.paused().await
+            {
+                let _ = proxy.set_paused(!is_paused).await;
+                return Ok(WaybarOutput::default());
+            }
+
+            return Err(crate::error::FluxoError::Module {
+                module: "dnd",
+                message: "No supported notification daemon found to toggle".to_string(),
+            });
+        }
+
         let is_dnd = state.dnd.borrow().is_dnd;
 
         if is_dnd {
@@ -47,6 +81,20 @@ pub struct DndDaemon;
 trait SwayncControl {
     #[zbus(property)]
     fn dnd(&self) -> zbus::Result<bool>;
+    #[zbus(property)]
+    fn set_dnd(&self, value: bool) -> zbus::Result<()>;
+}
+
+#[proxy(
+    interface = "org.dunstproject.cmd0",
+    default_service = "org.freedesktop.Notifications",
+    default_path = "/org/freedesktop/Notifications"
+)]
+trait DunstControl {
+    #[zbus(property)]
+    fn paused(&self) -> zbus::Result<bool>;
+    #[zbus(property)]
+    fn set_paused(&self, value: bool) -> zbus::Result<()>;
 }
 
 impl DndDaemon {
@@ -70,16 +118,13 @@ impl DndDaemon {
 
         info!("Connected to D-Bus for DND monitoring");
 
-        // Try SwayNC first
+        // Try SwayNC first (signal-based)
-        if let Ok(proxy) = SwayncControlProxy::new(&connection).await {
+        if let Ok(proxy) = SwayncControlProxy::new(&connection).await
-            debug!("Found SwayNC, using it for DND state.");
+            && let Ok(is_dnd) = proxy.dnd().await
+        {
+            debug!("Found SwayNC, using signal-based DND monitoring");
+            let _ = tx.send(DndState { is_dnd });
 
-            // Get initial state
-            if let Ok(is_dnd) = proxy.dnd().await {
-                let _ = tx.send(DndState { is_dnd });
-            }
-
-            // Monitor properties changed
             if let Ok(props_proxy) = PropertiesProxy::builder(&connection)
                 .destination("org.erikreider.swaync.control")?
                 .path("/org/erikreider/swaync/control")?
@@ -97,8 +142,72 @@ impl DndDaemon {
                     }
                 }
             }
+
+            return Err(anyhow::anyhow!("SwayNC DND stream ended"));
         }
 
-        Err(anyhow::anyhow!("DND stream ended or daemon not found"))
+        // Try Dunst (polling via raw D-Bus Properties.Get for maximum compatibility)
+        let props_proxy = PropertiesProxy::builder(&connection)
+            .destination("org.freedesktop.Notifications")?
+            .path("/org/freedesktop/Notifications")?
+            .build()
+            .await;
+
+        match &props_proxy {
+            Ok(_) => debug!("Created Properties proxy for Dunst"),
+            Err(e) => debug!("Failed to create Properties proxy for Dunst: {}", e),
+        }
+
+        if let Ok(props) = props_proxy {
+            // Read paused property via raw Properties.Get
+            let initial = props
+                .get(
+                    InterfaceName::from_static_str_unchecked("org.dunstproject.cmd0"),
+                    "paused",
+                )
+                .await;
+
+            match &initial {
+                Ok(_) => debug!("Successfully read Dunst paused property"),
+                Err(e) => debug!("Failed to read Dunst paused property: {}", e),
+            }
+
+            if let Ok(value) = initial
+                && let Ok(is_paused) = bool::try_from(&*value)
+            {
+                info!("Found Dunst, using polling-based DND monitoring");
+                let _ = tx.send(DndState { is_dnd: is_paused });
+
+                loop {
+                    tokio::time::sleep(Duration::from_secs(2)).await;
+                    match props
+                        .get(
+                            InterfaceName::from_static_str_unchecked("org.dunstproject.cmd0"),
+                            "paused",
+                        )
+                        .await
+                    {
+                        Ok(value) => {
+                            if let Ok(is_paused) = bool::try_from(&*value) {
+                                let current = tx.borrow().is_dnd;
+                                if current != is_paused {
+                                    let _ = tx.send(DndState { is_dnd: is_paused });
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            debug!("Dunst paused() poll failed: {}", e);
+                            break;
+                        }
+                    }
+                }
+
+                return Err(anyhow::anyhow!("Dunst connection lost"));
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "No supported notification daemon found (tried SwayNC, Dunst)"
+        ))
     }
 }

src/modules/gpu.rs

@@ -3,7 +3,7 @@ use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 pub struct GpuModule;
 
@@ -36,13 +36,7 @@ impl WaybarModule for GpuModule {
             });
         }
 
-        let class = if usage > 95.0 {
+        let class = classify_usage(usage, 75.0, 95.0);
-            "max"
-        } else if usage > 75.0 {
-            "high"
-        } else {
-            "normal"
-        };
 
         let format_str = match vendor.as_str() {
             "Intel" => &config.gpu.format_intel,

src/modules/memory.rs

@@ -3,7 +3,7 @@ use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
 use crate::state::AppReceivers;
-use crate::utils::{TokenValue, format_template};
+use crate::utils::{TokenValue, classify_usage, format_template};
 
 pub struct MemoryModule;
 
@@ -33,13 +33,7 @@ impl WaybarModule for MemoryModule {
             ],
         );
 
-        let class = if ratio > 95.0 {
+        let class = classify_usage(ratio, 75.0, 95.0);
-            "max"
-        } else if ratio > 75.0 {
-            "high"
-        } else {
-            "normal"
-        };
 
         Ok(WaybarOutput {
             text,

src/modules/mod.rs

@@ -1,18 +1,34 @@
+#[cfg(feature = "mod-audio")]
 pub mod audio;
+#[cfg(feature = "mod-dbus")]
 pub mod backlight;
+#[cfg(feature = "mod-bt")]
 pub mod bt;
+#[cfg(feature = "mod-hardware")]
 pub mod btrfs;
+#[cfg(feature = "mod-hardware")]
 pub mod cpu;
+#[cfg(feature = "mod-hardware")]
 pub mod disk;
+#[cfg(feature = "mod-dbus")]
 pub mod dnd;
+#[cfg(feature = "mod-hardware")]
 pub mod game;
+#[cfg(feature = "mod-hardware")]
 pub mod gpu;
+#[cfg(feature = "mod-hardware")]
 pub mod hardware;
+#[cfg(feature = "mod-dbus")]
 pub mod keyboard;
+#[cfg(feature = "mod-hardware")]
 pub mod memory;
+#[cfg(feature = "mod-dbus")]
 pub mod mpris;
+#[cfg(feature = "mod-network")]
 pub mod network;
+#[cfg(feature = "mod-hardware")]
 pub mod power;
+#[cfg(feature = "mod-hardware")]
 pub mod sys;
 
 use crate::config::Config;

src/modules/mpris.rs

@@ -2,12 +2,66 @@ use crate::config::Config;
 use crate::error::Result;
 use crate::modules::WaybarModule;
 use crate::output::WaybarOutput;
-use crate::state::{AppReceivers, MprisState};
+use crate::state::{AppReceivers, MprisScrollState, MprisState};
 use crate::utils::{TokenValue, format_template};
-use tokio::sync::watch;
+use std::sync::Arc;
+use tokio::sync::{RwLock, watch};
+use tokio::time::Duration;
 use tracing::{debug, info};
 use zbus::{Connection, proxy};
 
+fn format_mpris_text(format: &str, mpris: &MprisState) -> (String, &'static str) {
+    let status_icon = if mpris.is_playing {
+        "󰏤"
+    } else if mpris.is_paused {
+        "󰐊"
+    } else {
+        "󰓛"
+    };
+
+    let class = if mpris.is_playing {
+        "playing"
+    } else if mpris.is_paused {
+        "paused"
+    } else {
+        "stopped"
+    };
+
+    let text = format_template(
+        format,
+        &[
+            ("artist", TokenValue::String(mpris.artist.clone())),
+            ("title", TokenValue::String(mpris.title.clone())),
+            ("album", TokenValue::String(mpris.album.clone())),
+            ("status_icon", TokenValue::String(status_icon.to_string())),
+        ],
+    );
+
+    (text, class)
+}
+
+fn apply_scroll_window(full_text: &str, max_len: usize, offset: usize, separator: &str) -> String {
+    let char_count = full_text.chars().count();
+    let total_len = char_count + separator.chars().count();
+    let offset = offset % total_len;
+    full_text
+        .chars()
+        .chain(separator.chars())
+        .cycle()
+        .skip(offset)
+        .take(max_len)
+        .collect()
+}
+
+fn truncate_with_ellipsis(text: &str, max_len: usize) -> String {
+    let char_count = text.chars().count();
+    if char_count <= max_len {
+        return text.to_string();
+    }
+    let truncated: String = text.chars().take(max_len.saturating_sub(3)).collect();
+    format!("{}...", truncated)
+}
+
 pub struct MprisModule;
 
 impl WaybarModule for MprisModule {
@@ -28,32 +82,26 @@ impl WaybarModule for MprisModule {
             });
         }
 
-        let status_icon = if mpris.is_playing {
+        let (full_text, class) = format_mpris_text(&config.mpris.format, &mpris);
-            "󰏤"
-        } else if mpris.is_paused {
-            "󰐊"
-        } else {
-            "󰓛"
-        };
 
-        let class = if mpris.is_playing {
+        let text = if config.mpris.scroll {
-            "playing"
+            if let Some(max_len) = config.mpris.max_length {
-        } else if mpris.is_paused {
+                let scroll = state.mpris_scroll.read().await;
-            "paused"
+                apply_scroll_window(
+                    &full_text,
+                    max_len,
+                    scroll.offset,
+                    &config.mpris.scroll_separator,
+                )
+            } else {
+                full_text.clone()
+            }
+        } else if let Some(max_len) = config.mpris.max_length {
+            truncate_with_ellipsis(&full_text, max_len)
         } else {
-            "stopped"
+            full_text.clone()
         };
 
-        let text = format_template(
-            &config.mpris.format,
-            &[
-                ("artist", TokenValue::String(mpris.artist.clone())),
-                ("title", TokenValue::String(mpris.title.clone())),
-                ("album", TokenValue::String(mpris.album.clone())),
-                ("status_icon", TokenValue::String(status_icon.to_string())),
-            ],
-        );
-
         Ok(WaybarOutput {
             text,
             tooltip: Some(format!("{} - {}", mpris.artist, mpris.title)),
@@ -63,6 +111,54 @@ impl WaybarModule for MprisModule {
     }
 }
 
+pub async fn mpris_scroll_ticker(
+    config: Arc<RwLock<Config>>,
+    mut mpris_rx: watch::Receiver<MprisState>,
+    scroll_state: Arc<RwLock<MprisScrollState>>,
+    tick_tx: watch::Sender<u64>,
+) {
+    let mut generation: u64 = 0;
+    let mut last_track_key = String::new();
+
+    loop {
+        let mpris = mpris_rx.borrow_and_update().clone();
+        let cfg = config.read().await;
+        let scroll_enabled = cfg.mpris.scroll;
+        let has_max_length = cfg.mpris.max_length.is_some();
+        let scroll_speed = cfg.mpris.scroll_speed;
+        let format_str = cfg.mpris.format.clone();
+        drop(cfg);
+
+        let (full_text, _) = format_mpris_text(&format_str, &mpris);
+        let track_key = format!("{}|{}|{}", mpris.artist, mpris.title, mpris.album);
+
+        if track_key != last_track_key {
+            let mut state = scroll_state.write().await;
+            state.offset = 0;
+            state.full_text = full_text.clone();
+            last_track_key = track_key;
+            generation += 1;
+            let _ = tick_tx.send(generation);
+        }
+
+        if scroll_enabled && has_max_length && mpris.is_playing {
+            tokio::time::sleep(Duration::from_millis(scroll_speed)).await;
+            let mut state = scroll_state.write().await;
+            state.offset += 1;
+            state.full_text = full_text;
+            drop(state);
+            generation += 1;
+            let _ = tick_tx.send(generation);
+            continue;
+        }
+
+        // Not scrolling — wait for next state change
+        if mpris_rx.changed().await.is_err() {
+            break;
+        }
+    }
+}
+
 pub struct MprisDaemon;
 
 #[proxy(

src/registry.rs

@@ -0,0 +1,125 @@
+use crate::config::Config;
+use crate::error::{FluxoError, Result as FluxoResult};
+use crate::output::WaybarOutput;
+use crate::state::AppReceivers;
+
+#[allow(unused_imports)]
+use crate::modules::WaybarModule;
+
+pub async fn dispatch(
+    module_name: &str,
+    #[allow(unused)] config: &Config,
+    #[allow(unused)] state: &AppReceivers,
+    #[allow(unused)] args: &[&str],
+) -> FluxoResult<WaybarOutput> {
+    if !config.is_module_enabled(module_name) {
+        return Err(FluxoError::Disabled(module_name.to_string()));
+    }
+
+    match module_name {
+        #[cfg(feature = "mod-network")]
+        "net" | "network" => {
+            crate::modules::network::NetworkModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "cpu" => {
+            crate::modules::cpu::CpuModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "mem" | "memory" => {
+            crate::modules::memory::MemoryModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "disk" => {
+            crate::modules::disk::DiskModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "pool" | "btrfs" => {
+            crate::modules::btrfs::BtrfsModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-audio")]
+        "vol" | "audio" => {
+            crate::modules::audio::AudioModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-audio")]
+        "mic" => {
+            crate::modules::audio::AudioModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "gpu" => {
+            crate::modules::gpu::GpuModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "sys" => {
+            crate::modules::sys::SysModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-bt")]
+        "bt" | "bluetooth" => crate::modules::bt::BtModule.run(config, state, args).await,
+        #[cfg(feature = "mod-hardware")]
+        "power" => {
+            crate::modules::power::PowerModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-hardware")]
+        "game" => {
+            crate::modules::game::GameModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "backlight" => {
+            crate::modules::backlight::BacklightModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "kbd" | "keyboard" => {
+            crate::modules::keyboard::KeyboardModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "dnd" => {
+            crate::modules::dnd::DndModule
+                .run(config, state, args)
+                .await
+        }
+        #[cfg(feature = "mod-dbus")]
+        "mpris" => {
+            crate::modules::mpris::MprisModule
+                .run(config, state, args)
+                .await
+        }
+        _ => Err(FluxoError::Ipc(format!("Unknown module: {}", module_name))),
+    }
+}
+
+/// Returns the default args used by the signaler when evaluating a module.
+pub fn signaler_default_args(module_name: &str) -> &'static [&'static str] {
+    match module_name {
+        "disk" => &["/"],
+        "vol" | "audio" => &["sink", "show"],
+        "mic" => &["source", "show"],
+        "bt" | "bluetooth" => &["show"],
+        _ => &[],
+    }
+}

src/signaler.rs

@@ -1,8 +1,5 @@
 use crate::config::Config;
 use crate::state::AppReceivers;
-use nix::libc;
-use nix::sys::signal::{Signal, kill};
-use nix::unistd::Pid;
 use std::collections::HashMap;
 use std::sync::Arc;
 use sysinfo::{ProcessesToUpdate, System};
@@ -11,7 +8,7 @@ use tokio::time::{Duration, Instant, sleep};
 use tracing::{debug, warn};
 
 pub struct WaybarSignaler {
-    cached_pid: Option<Pid>,
+    cached_pid: Option<i32>,
     sys: System,
     last_signal_sent: HashMap<i32, Instant>,
 }
@@ -25,11 +22,11 @@ impl WaybarSignaler {
         }
     }
 
-    fn find_waybar_pid(&mut self) -> Option<Pid> {
+    fn find_waybar_pid(&mut self) -> Option<i32> {
         self.sys.refresh_processes(ProcessesToUpdate::All, true);
         for (pid, process) in self.sys.processes() {
             if process.name() == "waybar" {
-                return Some(Pid::from_raw(pid.as_u32() as i32));
+                return Some(pid.as_u32() as i32);
             }
         }
         None
@@ -44,7 +41,7 @@ impl WaybarSignaler {
 
         let mut valid_pid = false;
         if let Some(pid) = self.cached_pid
-            && kill(pid, None).is_ok()
+            && unsafe { libc::kill(pid, 0) } == 0
         {
             valid_pid = true;
         }
@@ -54,27 +51,13 @@ impl WaybarSignaler {
         }
 
         if let Some(pid) = self.cached_pid {
-            let rt_sig = match Signal::try_from(libc::SIGRTMIN() + signal_num) {
+            let sig = libc::SIGRTMIN() + signal_num;
-                Ok(sig) => sig,
+            if unsafe { libc::kill(pid, sig) } == 0 {
-                Err(_) => {
-                    unsafe {
-                        if libc::kill(pid.as_raw(), libc::SIGRTMIN() + signal_num) == 0 {
-                            debug!("Sent raw SIGRTMIN+{} to waybar (PID: {})", signal_num, pid);
-                            self.last_signal_sent.insert(signal_num, Instant::now());
-                        } else {
-                            warn!("Failed to send raw SIGRTMIN+{} to waybar", signal_num);
-                        }
-                    }
-                    return;
-                }
-            };
-
-            if let Err(e) = kill(pid, rt_sig) {
-                warn!("Failed to signal waybar: {}", e);
-                self.cached_pid = None;
-            } else {
                 debug!("Sent SIGRTMIN+{} to waybar (PID: {})", signal_num, pid);
                 self.last_signal_sent.insert(signal_num, Instant::now());
+            } else {
+                warn!("Failed to send SIGRTMIN+{} to waybar", signal_num);
+                self.cached_pid = None;
             }
         } else {
             debug!("Waybar process not found, skipping signal.");
@@ -107,46 +90,142 @@ impl WaybarSignaler {
                 };
             }
 
+            // For disabled features, create futures that never resolve
+            #[cfg(not(feature = "mod-network"))]
+            let net_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-network")]
+            let net_changed = receivers.network.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let cpu_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let cpu_changed = receivers.cpu.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let mem_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let mem_changed = receivers.memory.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let sys_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let sys_changed = receivers.sys.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let gpu_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let gpu_changed = receivers.gpu.changed();
+
+            #[cfg(not(feature = "mod-hardware"))]
+            let disks_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-hardware")]
+            let disks_changed = receivers.disks.changed();
+
+            #[cfg(not(feature = "mod-bt"))]
+            let bt_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-bt")]
+            let bt_changed = receivers.bluetooth.changed();
+
+            #[cfg(not(feature = "mod-audio"))]
+            let audio_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-audio")]
+            let audio_changed = receivers.audio.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let backlight_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let backlight_changed = receivers.backlight.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let keyboard_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let keyboard_changed = receivers.keyboard.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let dnd_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let dnd_changed = receivers.dnd.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let mpris_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let mpris_changed = receivers.mpris.changed();
+
+            #[cfg(not(feature = "mod-dbus"))]
+            let mpris_scroll_tick_changed = std::future::pending::<
+                std::result::Result<(), tokio::sync::watch::error::RecvError>,
+            >();
+            #[cfg(feature = "mod-dbus")]
+            let mpris_scroll_tick_changed = receivers.mpris_scroll_tick.changed();
+
             tokio::select! {
-                res = receivers.network.changed(), if signals.network.is_some() => {
+                res = net_changed, if signals.network.is_some() => {
                     if res.is_ok() { check_and_signal!("net", signals.network); }
                 }
-                res = receivers.cpu.changed(), if signals.cpu.is_some() => {
+                res = cpu_changed, if signals.cpu.is_some() => {
                     if res.is_ok() { check_and_signal!("cpu", signals.cpu); }
                 }
-                res = receivers.memory.changed(), if signals.memory.is_some() => {
+                res = mem_changed, if signals.memory.is_some() => {
                     if res.is_ok() { check_and_signal!("mem", signals.memory); }
                 }
-                res = receivers.sys.changed(), if signals.sys.is_some() => {
+                res = sys_changed, if signals.sys.is_some() => {
                     if res.is_ok() { check_and_signal!("sys", signals.sys); }
                 }
-                res = receivers.gpu.changed(), if signals.gpu.is_some() => {
+                res = gpu_changed, if signals.gpu.is_some() => {
                     if res.is_ok() { check_and_signal!("gpu", signals.gpu); }
                 }
-                res = receivers.disks.changed(), if signals.disk.is_some() => {
+                res = disks_changed, if signals.disk.is_some() => {
                     if res.is_ok() { check_and_signal!("disk", signals.disk); }
                 }
-                res = receivers.bluetooth.changed(), if signals.bt.is_some() => {
+                res = bt_changed, if signals.bt.is_some() => {
                     if res.is_ok() { check_and_signal!("bt", signals.bt); }
                 }
-                res = receivers.audio.changed(), if signals.audio.is_some() => {
+                res = audio_changed, if signals.audio.is_some() => {
                     if res.is_ok() {
                         check_and_signal!("vol", signals.audio);
                         check_and_signal!("mic", signals.audio);
                     }
                 }
-                res = receivers.backlight.changed(), if signals.backlight.is_some() => {
+                res = backlight_changed, if signals.backlight.is_some() => {
                     if res.is_ok() { check_and_signal!("backlight", signals.backlight); }
                 }
-                res = receivers.keyboard.changed(), if signals.keyboard.is_some() => {
+                res = keyboard_changed, if signals.keyboard.is_some() => {
                     if res.is_ok() { check_and_signal!("keyboard", signals.keyboard); }
                 }
-                res = receivers.dnd.changed(), if signals.dnd.is_some() => {
+                res = dnd_changed, if signals.dnd.is_some() => {
                     if res.is_ok() { check_and_signal!("dnd", signals.dnd); }
                 }
-                res = receivers.mpris.changed(), if signals.mpris.is_some() => {
+                res = mpris_changed, if signals.mpris.is_some() => {
                     if res.is_ok() { check_and_signal!("mpris", signals.mpris); }
                 }
+                res = mpris_scroll_tick_changed, if signals.mpris.is_some() => {
+                    if res.is_ok()
+                        && let Some(sig) = signals.mpris { self.send_signal(sig); }
+                }
                 _ = sleep(Duration::from_secs(5)) => {
                     // loop and refresh config
                 }

src/state.rs

@@ -6,20 +6,40 @@ use tokio::time::Instant;
 
 #[derive(Clone)]
 pub struct AppReceivers {
+    #[cfg(feature = "mod-network")]
     pub network: watch::Receiver<NetworkState>,
+    #[cfg(feature = "mod-hardware")]
     pub cpu: watch::Receiver<CpuState>,
+    #[cfg(feature = "mod-hardware")]
     pub memory: watch::Receiver<MemoryState>,
+    #[cfg(feature = "mod-hardware")]
     pub sys: watch::Receiver<SysState>,
+    #[cfg(feature = "mod-hardware")]
     pub gpu: watch::Receiver<GpuState>,
+    #[cfg(feature = "mod-hardware")]
     pub disks: watch::Receiver<Vec<DiskInfo>>,
+    #[cfg(feature = "mod-bt")]
     pub bluetooth: watch::Receiver<BtState>,
+    #[cfg(feature = "mod-bt")]
+    pub bt_cycle: Arc<RwLock<usize>>,
+    #[cfg(feature = "mod-audio")]
     pub audio: watch::Receiver<AudioState>,
+    #[cfg(feature = "mod-dbus")]
     pub mpris: watch::Receiver<MprisState>,
+    #[cfg(feature = "mod-dbus")]
     pub backlight: watch::Receiver<BacklightState>,
+    #[cfg(feature = "mod-dbus")]
     pub keyboard: watch::Receiver<KeyboardState>,
+    #[cfg(feature = "mod-dbus")]
     pub dnd: watch::Receiver<DndState>,
+    #[cfg(feature = "mod-dbus")]
+    pub mpris_scroll: Arc<RwLock<MprisScrollState>>,
+    #[cfg(feature = "mod-dbus")]
+    pub mpris_scroll_tick: watch::Receiver<u64>,
     pub health: Arc<RwLock<HashMap<String, ModuleHealth>>>,
+    #[cfg(feature = "mod-bt")]
     pub bt_force_poll: mpsc::Sender<()>,
+    #[cfg(feature = "mod-audio")]
     pub audio_cmd_tx: mpsc::Sender<crate::modules::audio::AudioCommand>,
 }
 
@@ -58,15 +78,29 @@ pub struct AudioSourceInfo {
 }
 
 #[derive(Default, Clone)]
-pub struct BtState {
+pub struct BtDeviceInfo {
-    pub connected: bool,
-    pub adapter_powered: bool,
     pub device_alias: String,
     pub device_address: String,
     pub battery_percentage: Option<u8>,
     pub plugin_data: Vec<(String, String)>,
 }
 
+#[derive(Default, Clone)]
+pub struct BtState {
+    pub adapter_powered: bool,
+    pub devices: Vec<BtDeviceInfo>,
+}
+
+impl BtState {
+    pub fn active_device(&self, index: usize) -> Option<&BtDeviceInfo> {
+        if self.devices.is_empty() {
+            None
+        } else {
+            Some(&self.devices[index % self.devices.len()])
+        }
+    }
+}
+
 #[derive(Default, Clone)]
 pub struct DiskInfo {
     pub mount_point: String,
@@ -155,6 +189,12 @@ pub struct BacklightState {
     pub percentage: u8,
 }
 
+#[derive(Default, Clone)]
+pub struct MprisScrollState {
+    pub offset: usize,
+    pub full_text: String,
+}
+
 #[derive(Default, Clone)]
 pub struct MprisState {
     pub is_playing: bool,
@@ -168,85 +208,157 @@ pub struct MprisState {
 #[cfg(test)]
 pub struct MockState {
     pub receivers: AppReceivers,
-    // Keep senders alive so receivers don't return Closed errors
+    #[cfg(feature = "mod-network")]
     _net_tx: watch::Sender<NetworkState>,
+    #[cfg(feature = "mod-hardware")]
     _cpu_tx: watch::Sender<CpuState>,
+    #[cfg(feature = "mod-hardware")]
     _mem_tx: watch::Sender<MemoryState>,
+    #[cfg(feature = "mod-hardware")]
     _sys_tx: watch::Sender<SysState>,
+    #[cfg(feature = "mod-hardware")]
     _gpu_tx: watch::Sender<GpuState>,
+    #[cfg(feature = "mod-hardware")]
     _disks_tx: watch::Sender<Vec<DiskInfo>>,
+    #[cfg(feature = "mod-bt")]
     _bt_tx: watch::Sender<BtState>,
+    #[cfg(feature = "mod-audio")]
     _audio_tx: watch::Sender<AudioState>,
+    #[cfg(feature = "mod-dbus")]
     _mpris_tx: watch::Sender<MprisState>,
+    #[cfg(feature = "mod-dbus")]
     _backlight_tx: watch::Sender<BacklightState>,
+    #[cfg(feature = "mod-dbus")]
     _keyboard_tx: watch::Sender<KeyboardState>,
+    #[cfg(feature = "mod-dbus")]
     _dnd_tx: watch::Sender<DndState>,
 }
 
 #[cfg(test)]
 #[derive(Default, Clone)]
 pub struct AppState {
+    #[cfg(feature = "mod-network")]
     pub network: NetworkState,
+    #[cfg(feature = "mod-hardware")]
     pub cpu: CpuState,
+    #[cfg(feature = "mod-hardware")]
     pub memory: MemoryState,
+    #[cfg(feature = "mod-hardware")]
     pub sys: SysState,
+    #[cfg(feature = "mod-hardware")]
     pub gpu: GpuState,
+    #[cfg(feature = "mod-hardware")]
     pub disks: Vec<DiskInfo>,
+    #[cfg(feature = "mod-bt")]
     pub bluetooth: BtState,
+    #[cfg(feature = "mod-audio")]
     pub audio: AudioState,
+    #[cfg(feature = "mod-dbus")]
     pub mpris: MprisState,
+    #[cfg(feature = "mod-dbus")]
     pub backlight: BacklightState,
+    #[cfg(feature = "mod-dbus")]
     pub keyboard: KeyboardState,
+    #[cfg(feature = "mod-dbus")]
     pub dnd: DndState,
     pub health: HashMap<String, ModuleHealth>,
 }
 
 #[cfg(test)]
 pub fn mock_state(state: AppState) -> MockState {
+    #[cfg(feature = "mod-network")]
     let (net_tx, net_rx) = watch::channel(state.network);
+    #[cfg(feature = "mod-hardware")]
     let (cpu_tx, cpu_rx) = watch::channel(state.cpu);
+    #[cfg(feature = "mod-hardware")]
     let (mem_tx, mem_rx) = watch::channel(state.memory);
+    #[cfg(feature = "mod-hardware")]
     let (sys_tx, sys_rx) = watch::channel(state.sys);
+    #[cfg(feature = "mod-hardware")]
     let (gpu_tx, gpu_rx) = watch::channel(state.gpu);
+    #[cfg(feature = "mod-hardware")]
     let (disks_tx, disks_rx) = watch::channel(state.disks);
+    #[cfg(feature = "mod-bt")]
     let (bt_tx, bt_rx) = watch::channel(state.bluetooth);
+    #[cfg(feature = "mod-audio")]
     let (audio_tx, audio_rx) = watch::channel(state.audio);
+    #[cfg(feature = "mod-dbus")]
     let (mpris_tx, mpris_rx) = watch::channel(state.mpris);
+    #[cfg(feature = "mod-dbus")]
     let (backlight_tx, backlight_rx) = watch::channel(state.backlight);
+    #[cfg(feature = "mod-dbus")]
     let (keyboard_tx, keyboard_rx) = watch::channel(state.keyboard);
+    #[cfg(feature = "mod-dbus")]
     let (dnd_tx, dnd_rx) = watch::channel(state.dnd);
+    #[cfg(feature = "mod-bt")]
     let (bt_force_tx, _) = mpsc::channel(1);
+    #[cfg(feature = "mod-audio")]
     let (audio_cmd_tx, _) = mpsc::channel(1);
 
     MockState {
         receivers: AppReceivers {
+            #[cfg(feature = "mod-network")]
             network: net_rx,
+            #[cfg(feature = "mod-hardware")]
             cpu: cpu_rx,
+            #[cfg(feature = "mod-hardware")]
             memory: mem_rx,
+            #[cfg(feature = "mod-hardware")]
             sys: sys_rx,
+            #[cfg(feature = "mod-hardware")]
             gpu: gpu_rx,
+            #[cfg(feature = "mod-hardware")]
             disks: disks_rx,
+            #[cfg(feature = "mod-bt")]
             bluetooth: bt_rx,
+            #[cfg(feature = "mod-bt")]
+            bt_cycle: Arc::new(RwLock::new(0usize)),
+            #[cfg(feature = "mod-audio")]
             audio: audio_rx,
+            #[cfg(feature = "mod-dbus")]
             mpris: mpris_rx,
+            #[cfg(feature = "mod-dbus")]
             backlight: backlight_rx,
+            #[cfg(feature = "mod-dbus")]
             keyboard: keyboard_rx,
+            #[cfg(feature = "mod-dbus")]
             dnd: dnd_rx,
+            #[cfg(feature = "mod-dbus")]
+            mpris_scroll: Arc::new(RwLock::new(MprisScrollState::default())),
+            #[cfg(feature = "mod-dbus")]
+            mpris_scroll_tick: {
+                let (_, rx) = watch::channel(0u64);
+                rx
+            },
             health: Arc::new(RwLock::new(state.health)),
+            #[cfg(feature = "mod-bt")]
             bt_force_poll: bt_force_tx,
+            #[cfg(feature = "mod-audio")]
             audio_cmd_tx,
         },
+        #[cfg(feature = "mod-network")]
         _net_tx: net_tx,
+        #[cfg(feature = "mod-hardware")]
         _cpu_tx: cpu_tx,
+        #[cfg(feature = "mod-hardware")]
         _mem_tx: mem_tx,
+        #[cfg(feature = "mod-hardware")]
         _sys_tx: sys_tx,
+        #[cfg(feature = "mod-hardware")]
         _gpu_tx: gpu_tx,
+        #[cfg(feature = "mod-hardware")]
         _disks_tx: disks_tx,
+        #[cfg(feature = "mod-bt")]
         _bt_tx: bt_tx,
+        #[cfg(feature = "mod-audio")]
         _audio_tx: audio_tx,
+        #[cfg(feature = "mod-dbus")]
         _mpris_tx: mpris_tx,
+        #[cfg(feature = "mod-dbus")]
         _backlight_tx: backlight_tx,
+        #[cfg(feature = "mod-dbus")]
         _keyboard_tx: keyboard_tx,
+        #[cfg(feature = "mod-dbus")]
         _dnd_tx: dnd_tx,
     }
 }

src/utils.rs

@@ -70,42 +70,52 @@ pub fn get_hyprland_socket(socket_name: &str) -> Result<std::path::PathBuf> {
 use regex::Regex;
 use std::sync::LazyLock;
 
+pub fn classify_usage(value: f64, high: f64, max: f64) -> &'static str {
+    if value > max {
+        "max"
+    } else if value > high {
+        "high"
+    } else {
+        "normal"
+    }
+}
+
 pub enum TokenValue {
     Float(f64),
     Int(i64),
     String(String),
 }
 
+pub static TOKEN_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap());
+
 pub fn format_template<K>(template: &str, values: &[(K, TokenValue)]) -> String
 where
     K: AsRef<str>,
 {
-    static RE: LazyLock<Regex> = LazyLock::new(|| {
+    TOKEN_RE
-        Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap()
+        .replace_all(template, |caps: &regex::Captures| {
-    });
+            let name = &caps[1];
+            if let Some((_, val)) = values.iter().find(|(k, _)| k.as_ref() == name) {
+                let align = caps.get(2).map(|m| m.as_str()).unwrap_or(">");
+                let width = caps
+                    .get(3)
+                    .map(|m| m.as_str().parse::<usize>().unwrap_or(0))
+                    .unwrap_or(0);
+                let precision = caps
+                    .get(4)
+                    .map(|m| m.as_str().parse::<usize>().unwrap_or(0));
 
-    RE.replace_all(template, |caps: &regex::Captures| {
+                match val {
-        let name = &caps[1];
+                    TokenValue::Float(f) => format_float(*f, align, width, precision),
-        if let Some((_, val)) = values.iter().find(|(k, _)| k.as_ref() == name) {
+                    TokenValue::Int(i) => format_int(*i, align, width),
-            let align = caps.get(2).map(|m| m.as_str()).unwrap_or(">");
+                    TokenValue::String(s) => format_str(s, align, width),
-            let width = caps
+                }
-                .get(3)
+            } else {
-                .map(|m| m.as_str().parse::<usize>().unwrap_or(0))
+                caps[0].to_string()
-                .unwrap_or(0);
-            let precision = caps
-                .get(4)
-                .map(|m| m.as_str().parse::<usize>().unwrap_or(0));
-
-            match val {
-                TokenValue::Float(f) => format_float(*f, align, width, precision),
-                TokenValue::Int(i) => format_int(*i, align, width),
-                TokenValue::String(s) => format_str(s, align, width),
             }
-        } else {
+        })
-            caps[0].to_string()
+        .into_owned()
-        }
-    })
-    .into_owned()
 }
 
 fn format_float(f: f64, align: &str, width: usize, precision: Option<usize>) -> String {